| #!/usr/bin/python |
| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| |
| # FileSR: local-file storage repository |
| import SR, VDI, SRCommand, FileSR, util |
| import errno |
| import os, re, sys, stat |
| import time |
| import xml.dom.minidom |
| import xs_errors |
| import nfs |
| import vhdutil |
| from lock import Lock |
| import cleanup |
| |
| CAPABILITIES = ["SR_PROBE","SR_UPDATE", "SR_CACHING", \ |
| "VDI_CREATE","VDI_DELETE","VDI_ATTACH","VDI_DETACH", \ |
| "VDI_UPDATE", "VDI_CLONE","VDI_SNAPSHOT","VDI_RESIZE", \ |
| "VDI_RESIZE_ONLINE", "VDI_RESET_ON_BOOT", "ATOMIC_PAUSE"] |
| |
| CONFIGURATION = [ [ 'server', 'hostname or IP address of NFS server (required)' ], \ |
| [ 'serverpath', 'path on remote server (required)' ] ] |
| |
| |
| DRIVER_INFO = { |
| 'name': 'NFS VHD', |
| 'description': 'SR plugin which stores disks as VHD files on a remote NFS filesystem', |
| 'vendor': 'The Apache Software Foundation', |
| 'copyright': 'Copyright (c) 2012 The Apache Software Foundation', |
| 'driver_version': '1.0', |
| 'required_api_version': '1.0', |
| 'capabilities': CAPABILITIES, |
| 'configuration': CONFIGURATION |
| } |
| |
| |
| # The mountpoint for the directory when performing an sr_probe. All probes |
| PROBE_MOUNTPOINT = "probe" |
| NFSPORT = 2049 |
| DEFAULT_TRANSPORT = "tcp" |
| |
| |
| class NFSSR(FileSR.FileSR): |
| """NFS file-based storage repository""" |
| def handles(type): |
| return type == 'nfs' |
| handles = staticmethod(handles) |
| |
| |
| def load(self, sr_uuid): |
| self.ops_exclusive = FileSR.OPS_EXCLUSIVE |
| self.lock = Lock(vhdutil.LOCK_TYPE_SR, self.uuid) |
| self.sr_vditype = SR.DEFAULT_TAP |
| if not self.dconf.has_key('server'): |
| raise xs_errors.XenError('ConfigServerMissing') |
| self.remoteserver = self.dconf['server'] |
| self.path = os.path.join(SR.MOUNT_BASE, sr_uuid) |
| |
| # Test for the optional 'nfsoptions' dconf attribute |
| self.transport = DEFAULT_TRANSPORT |
| if self.dconf.has_key('useUDP') and self.dconf['useUDP'] == 'true': |
| self.transport = "udp" |
| |
| |
| def validate_remotepath(self, scan): |
| if not self.dconf.has_key('serverpath'): |
| if scan: |
| try: |
| self.scan_exports(self.dconf['server']) |
| except: |
| pass |
| raise xs_errors.XenError('ConfigServerPathMissing') |
| if not self._isvalidpathstring(self.dconf['serverpath']): |
| raise xs_errors.XenError('ConfigServerPathBad', \ |
| opterr='serverpath is %s' % self.dconf['serverpath']) |
| |
| def check_server(self): |
| try: |
| nfs.check_server_tcp(self.remoteserver) |
| except nfs.NfsException, exc: |
| raise xs_errors.XenError('NFSVersion', |
| opterr=exc.errstr) |
| |
| |
| def mount(self, mountpoint, remotepath): |
| try: |
| nfs.soft_mount(mountpoint, self.remoteserver, remotepath, self.transport) |
| except nfs.NfsException, exc: |
| raise xs_errors.XenError('NFSMount', opterr=exc.errstr) |
| |
| |
| def attach(self, sr_uuid): |
| self.validate_remotepath(False) |
| #self.remotepath = os.path.join(self.dconf['serverpath'], sr_uuid) |
| self.remotepath = self.dconf['serverpath'] |
| util._testHost(self.dconf['server'], NFSPORT, 'NFSTarget') |
| self.mount_remotepath(sr_uuid) |
| |
| |
| def mount_remotepath(self, sr_uuid): |
| if not self._checkmount(): |
| self.check_server() |
| self.mount(self.path, self.remotepath) |
| |
| return super(NFSSR, self).attach(sr_uuid) |
| |
| |
| def probe(self): |
| # Verify NFS target and port |
| util._testHost(self.dconf['server'], NFSPORT, 'NFSTarget') |
| |
| self.validate_remotepath(True) |
| self.check_server() |
| |
| temppath = os.path.join(SR.MOUNT_BASE, PROBE_MOUNTPOINT) |
| |
| self.mount(temppath, self.dconf['serverpath']) |
| try: |
| return nfs.scan_srlist(temppath) |
| finally: |
| try: |
| nfs.unmount(temppath, True) |
| except: |
| pass |
| |
| |
| def detach(self, sr_uuid): |
| """Detach the SR: Unmounts and removes the mountpoint""" |
| if not self._checkmount(): |
| return |
| util.SMlog("Aborting GC/coalesce") |
| cleanup.abort(self.uuid) |
| |
| # Change directory to avoid unmount conflicts |
| os.chdir(SR.MOUNT_BASE) |
| |
| try: |
| nfs.unmount(self.path, True) |
| except nfs.NfsException, exc: |
| raise xs_errors.XenError('NFSUnMount', opterr=exc.errstr) |
| |
| return super(NFSSR, self).detach(sr_uuid) |
| |
| |
| def create(self, sr_uuid, size): |
| util._testHost(self.dconf['server'], NFSPORT, 'NFSTarget') |
| self.validate_remotepath(True) |
| if self._checkmount(): |
| raise xs_errors.XenError('NFSAttached') |
| |
| # Set the target path temporarily to the base dir |
| # so that we can create the target SR directory |
| self.remotepath = self.dconf['serverpath'] |
| try: |
| self.mount_remotepath(sr_uuid) |
| except Exception, exn: |
| try: |
| os.rmdir(self.path) |
| except: |
| pass |
| raise exn |
| |
| #newpath = os.path.join(self.path, sr_uuid) |
| #if util.ioretry(lambda: util.pathexists(newpath)): |
| # if len(util.ioretry(lambda: util.listdir(newpath))) != 0: |
| # self.detach(sr_uuid) |
| # raise xs_errors.XenError('SRExists') |
| #else: |
| # try: |
| # util.ioretry(lambda: util.makedirs(newpath)) |
| # except util.CommandException, inst: |
| # if inst.code != errno.EEXIST: |
| # self.detach(sr_uuid) |
| # raise xs_errors.XenError('NFSCreate', |
| # opterr='remote directory creation error is %d' |
| # % inst.code) |
| self.detach(sr_uuid) |
| |
| def delete(self, sr_uuid): |
| # try to remove/delete non VDI contents first |
| super(NFSSR, self).delete(sr_uuid) |
| try: |
| if self._checkmount(): |
| self.detach(sr_uuid) |
| |
| # Set the target path temporarily to the base dir |
| # so that we can remove the target SR directory |
| self.remotepath = self.dconf['serverpath'] |
| self.mount_remotepath(sr_uuid) |
| newpath = os.path.join(self.path, sr_uuid) |
| |
| if util.ioretry(lambda: util.pathexists(newpath)): |
| util.ioretry(lambda: os.rmdir(newpath)) |
| self.detach(sr_uuid) |
| except util.CommandException, inst: |
| self.detach(sr_uuid) |
| if inst.code != errno.ENOENT: |
| raise xs_errors.XenError('NFSDelete') |
| |
| def vdi(self, uuid, loadLocked = False): |
| if not loadLocked: |
| return NFSFileVDI(self, uuid) |
| return NFSFileVDI(self, uuid) |
| |
| def _checkmount(self): |
| return util.ioretry(lambda: util.pathexists(self.path)) \ |
| and util.ioretry(lambda: util.ismount(self.path)) |
| |
| def scan_exports(self, target): |
| util.SMlog("scanning2 (target=%s)" % target) |
| dom = nfs.scan_exports(target) |
| print >>sys.stderr,dom.toprettyxml() |
| |
| class NFSFileVDI(FileSR.FileVDI): |
| def attach(self, sr_uuid, vdi_uuid): |
| try: |
| vdi_ref = self.sr.srcmd.params['vdi_ref'] |
| self.session.xenapi.VDI.remove_from_xenstore_data(vdi_ref, \ |
| "vdi-type") |
| self.session.xenapi.VDI.remove_from_xenstore_data(vdi_ref, \ |
| "storage-type") |
| self.session.xenapi.VDI.add_to_xenstore_data(vdi_ref, \ |
| "storage-type", "nfs") |
| except: |
| util.logException("NFSSR:attach") |
| pass |
| return super(NFSFileVDI, self).attach(sr_uuid, vdi_uuid) |
| |
| def get_mtime(self, path): |
| st = util.ioretry_stat(lambda: os.stat(path)) |
| return st[stat.ST_MTIME] |
| |
| def clone(self, sr_uuid, vdi_uuid): |
| timestamp_before = int(self.get_mtime(self.sr.path)) |
| ret = super(NFSFileVDI, self).clone(sr_uuid, vdi_uuid) |
| timestamp_after = int(self.get_mtime(self.sr.path)) |
| if timestamp_after == timestamp_before: |
| util.SMlog("SR dir timestamp didn't change, updating") |
| timestamp_after += 1 |
| os.utime(self.sr.path, (timestamp_after, timestamp_after)) |
| return ret |
| |
| |
| if __name__ == '__main__': |
| SRCommand.run(NFSSR, DRIVER_INFO) |
| else: |
| SR.registerSR(NFSSR) |
