mount

 Unmount the distribution point.

 Does nothing if it wasn't mounted with #mount.

 @return [void]
344879
def unmount
      return nil unless mounted?
      if system "/sbin/umount '#{@mountpoint}'"
        sleep 1 # the umount takes time.
        @mountpoint.rmdir if @mountpoint.directory? and (not @mountpoint.mountpoint?)
        @mounted = false
      else
        raise  JSS::FileServiceError ,"There was a problem unmounting #{@mountpoint}"
      end
      nil
    end
957375
function unmountRedundant(items, tags) {
      var i = tags.length;
      var j = items.length;

      while (i > j) {
        i--;
        remove.apply(tags[i], [tags, i]);
      }
    }
782915
func (m *execMounter) Unmount(target string) error {
	outputBytes, err := m.exec.Run("umount", target)
	if err == nil {
		klog.V(5).Infof("Exec unmounted %s: %s", target, string(outputBytes))
	} else {
		klog.V(5).Infof("Failed to exec unmount %s: err: %q, umount output: %s", target, err, string(outputBytes))
	}

	return err
}
1185003
def reachable_for_upload? (pw)
      return :mountable if mounted?
      return false unless check_pw :rw , pw
      begin
        mount pw, :rw
        return :mountable
      rescue
        return false
      ensure
        unmount
      end
    end
826566
def _clear_mountpoint(self):
        """"""

        if self.mountpoint:
            os.rmdir(self.mountpoint)
            self.mountpoint = ""
1001979
function unmountComponentFromNode(instance, container, safely) {
	  if (false) {
	    ReactInstrumentation.debugTool.onBeginFlush();
	  }
	  ReactReconciler.unmountComponent(instance, safely);
	  if (false) {
	    ReactInstrumentation.debugTool.onEndFlush();
	  }
	
	  if (container.nodeType === DOC_NODE_TYPE) {
	    container = container.documentElement;
	  }
	
	  // http://jsperf.com/emptying-a-node
	  while (container.lastChild) {
	    container.removeChild(container.lastChild);
	  }
	}
977011
def mount(self):
        """"""
        if not self.is_mounted():
            # OS X mounting is handled automagically in /Volumes:
            # DO NOT mkdir there!
            # For Linux, ensure the mountpoint exists.
            if not is_osx():
                if not os.path.exists(self.connection["mount_point"]):
                    os.mkdir(self.connection["mount_point"])
            self._mount()
641429
def unmount(self, force=None, auth_no_user_interaction=None):
        """"""
        return self._M.Filesystem.Unmount(
            '(a{sv})',
            filter_opt({
                'force': ('b', force),
                'auth.no_user_interaction': ('b', auth_no_user_interaction),
            })
        )
1010345
def unmount(self, cid):
        
        driver = self.client.info()['Driver']
        driver_unmount_fn = getattr(self, "_unmount_" + driver,
                                    self._unsupported_backend)
        driver_unmount_fn(cid)
1148983
def mount_partitions(device, mount_prefix = '')
      @log.trace "Mounting partitions..."

      partitions = mountable_partitions(device)
      mount_points = LinuxHelper.new(:log => @log).partition_mount_points(@appliance_config.hardware.partitions)
      # https://issues.jboss.org/browse/BGBUILD-307
      # We don't want to mount swap partitions at all...
      mount_points.delete("swap")
      partitions.each_index { |i| mount_partition(partitions[i], mount_points[i], mount_prefix) }
    end
153144
def unmount(self, path):
        
        del self._mountpoints[self._join_chunks(self._normalize_path(path))]
1045893
func Unmount(r mountRunner, target string) error {
	cmd := umountCmd(target, false)
	glog.Infof("Will run: %s", cmd)
	out, err := r.CombinedOutput(cmd)
	if err == nil {
		return nil
	}
	glog.Warningf("initial unmount error: %v, out: %s", err, out)

	// Try again, using force if needed.
	cmd = umountCmd(target, true)
	glog.Infof("Will run: %s", cmd)
	out, err = r.CombinedOutput(cmd)
	glog.Infof("unmount force err=%v, out=%s", err, out)
	if err != nil {
		return errors.Wrap(err, out)
	}
	return nil
}
1134685
func (m *DefaultMounter) Unmount(target string, flags int, timeout int) error {
	return syscall.Unmount(target, flags)
}
1015233
def command_umount(self, system_id, *system_ids):
        
        system_ids = (system_id,) + system_ids
        has_failed = False
        for system_id in system_ids:
            try:
                system = SystemModel.create_by_id(system_id, self.environment)
                controller = SystemControllerModel(system, self.environment)
                controller.unmount()
            except SftpConfigException as e:
                sys.stderr.write('Cannot unmount %s: %s\n\n' % (system_id, str(e)))
                has_failed = True
        if has_failed:
            sys.exit(1)
340738
func (daemon *Daemon) Unmount(container *container.Container) error {
	if container.RWLayer == nil {
		return errors.New("RWLayer of container " + container.ID + " is unexpectedly nil")
	}
	if err := container.RWLayer.Unmount(); err != nil {
		logrus.Errorf("Error unmounting container %s: %s", container.ID, err)
		return err
	}

	return nil
}
427944
def unstash_it(self, sync=False):
        
        if self.stash_index is not None:
            return self.git_exec(
                ['stash', 'pop', 'stash@{{{0}}}'.format(self.stash_index)])
700739
def mount_proc(dir, proc=nil, &block)
      proc ||= block
      raise HTTPServerError, "must pass a proc or block" unless proc
      mount(dir, HTTPServlet::ProcHandler.new(proc))
    end