tree a0599d21fd3a778de66cd9846aae25ccb4eac682
parent 23b268906b9f99f5c20e77363322d501d61db1d3
author Andrey Yegorov <8622884+dlg99@users.noreply.github.com> 1613592794 -0800
committer GitHub <noreply@github.com> 1613592794 +0100
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsBcBAABCAAQBQJgLXjaCRBK7hj4Ov3rIwAAdHIIAHMeNJatCiIh+T225rssuTrG
 +5yqUXLWjgQvepUy9DleHw6c+6EQTwt9U4Ay/flwTqGDc9BoOOcifO/hAHLr/3NT
 o+bZIkwxZVWBxsPFjiorEF7/lsZRFOguAn6BBYFpnA4aHuClpd8I0fum3VWWXWUY
 XSby2z+9uYiUQPZrW0xnur1Myi56Uj97ul0f/ul7weDXCfzEn23/FuGCoTLqC+YB
 uNlltouNCYBCfRnCFPBo35sDU1eCeCJl1bPSTe7BzshiE+yZPjfd6nQsIZB4R2Cp
 BAKu8McxlrR1L5T50p1jbRVvm9DCEBSW7ln5ih8/y1+8xCyRMo3XkGX5z8/Www0=
 =2z21
 -----END PGP SIGNATURE-----
 

Release script does not work on MacOs Big Sur

Descriptions of the changes in this PR:

Fixed the script/docker run command to mount to `/home/$USER` instead of mac-style `/Users/$USER`. 

### Motivation

`dev/release/000-run-docker.sh` failed to mount source dir (got empty dir instead), printed permissions errors like
```
mkdir: cannot create directory '/root': Permission denied
Can not write to /root/.m2/copy_reference_file.log. Wrong volume permissions? Carrying on ...
```

### Changes

see above



Reviewers: Enrico Olivelli <eolivelli@gmail.com>

This closes #2608 from dlg99/master-release-docker-mac