text: from abc import ABCMeta
  from abc import abstractmethod
  from bootstrapvz.common.sectors import Sectors
  from bootstrapvz.common.tools import log_check_call
  from bootstrapvz.common.fsm_proxy import FSMProxy
  
  
  class AbstractPartition(FSMProxy):
      """Abstract representation of a partiton
      This class is a finite state machine and represents the state of the real partition
      """
  
      __metaclass__ = ABCMeta
  
      # Our states
      events = [{'name': 'create', 'src': 'nonexistent', 'dst': 'created'},
                {'name': 'format', 'src': 'created', 'dst': 'formatted'},
                {'name': 'mount', 'src': 'formatted', 'dst': 'mounted'},
                {'name': 'unmount', 'src': 'mounted', 'dst': 'formatted'},
                ]
  
      def __init__(self, size, filesystem, format_command):
          """
          :param Bytes size: Size of the partition
          :param str filesystem: Filesystem the partition should be formatted with
          :param list format_command: Optional format command, valid variables are fs, device_path and size
          """
          self.size           = size
          self.filesystem     = filesystem
          self.format_command = format_command
          # Initialize the start & end padding to 0 sectors, may be changed later
          self.pad_start = Sectors(0, size.sector_size)
          self.pad_end = Sectors(0, size.sector_size)
          # Path to the partition
          self.device_path    = None
          # Dictionary with mount points as keys and Mount objects as values
          self.mounts         = {}
  
          # Create the configuration for our state machine
          cfg = {'initial': 'nonexistent', 'events': self.events, 'callbacks': {}}
          super(AbstractPartition, self).__init__(cfg)
  
      def get_uuid(self):
          """Gets the UUID of the partition
  
          :return: The UUID of the partition
          :rtype: str
          """
          [uuid] = log_check_call(['blkid', '-s', 'UUID', '-o', 'value', self.device_path])
          return uuid
  
      @abstractmethod
      def get_start(self):
          pass
  
      def get_end(self):
          """Gets the end of the partition
  
          :return: The end of the partition
          :rtype: Sectors
          """
          return self.get_start() + self.pad_start + self.size + self.pad_end
  
      def _before_format(self, e):
          """Formats the partition
          """
          # If there is no explicit format_command define we simply call mkfs.fstype
          if self.format_command is None:
              format_command = ['mkfs.{fs}', '{device_path}']
          else:
              format_command = self.format_command
          variables = {'fs': self.filesystem,
                       'device_path': self.device_path,
                       'size': self.size,
                       }
          command = map(lambda part: part.format(**variables), format_command)
          # Format the partition
          log_check_call(command)
  
      def _before_mount(self, e):
          """Mount the partition
          """
          log_check_call(['mount', '--types', self.filesystem, self.device_path, e.destination])
          self.mount_dir = e.destination
  
      def _after_mount(self, e):
          """Mount any mounts associated with this partition
          """
          # Make sure we mount in ascending order of mountpoint path length
          # This ensures that we don't mount /dev/pts before we mount /dev
          for destination in sorted(self.mounts.iterkeys(), key=len):
              self.mounts[destination].mount(self.mount_dir)
  
      def _before_unmount(self, e):
          """Unmount any mounts associated with this partition
          """
          # Unmount the mounts in descending order of mounpoint path length
          # You cannot unmount /dev before you have unmounted /dev/pts
          for destination in sorted(self.mounts.iterkeys(), key=len, reverse=True):
              self.mounts[destination].unmount()
          log_check_call(['umount', self.mount_dir])
          del self.mount_dir
  
      def add_mount(self, source, destination, opts=[]):
          """Associate a mount with this partition
          Automatically mounts it
  
          :param str,AbstractPartition source: The source of the mount
          :param str destination: The path to the mountpoint
          :param list opts: Any options that should be passed to the mount command
          """
          # Create a new mount object, mount it if the partition is mounted and put it in the mounts dict
          from mount import Mount
          mount = Mount(source, destination, opts)
          if self.fsm.current == 'mounted':
              mount.mount(self.mount_dir)
          self.mounts[destination] = mount
  
      def remove_mount(self, destination):
          """Remove a mount from this partition
          Automatically unmounts it
  
          :param str destination: The mountpoint path of the mount that should be removed
          """
          # Unmount the mount if the partition is mounted and delete it from the mounts dict
          # If the mount is already unmounted and the source is a partition, this will raise an exception
          if self.fsm.current == 'mounted':
              self.mounts[destination].unmount()
          del self.mounts[destination]
  