def run(self):
print_header("Setting up Vim")
if not "plugged" in self.args:
self.check_nvim_installed()
self.link_config()
self.download_vim_plugged()
run_command("nvim +PlugInstall +qall")
def run(self):
if not platform.is_arch:
return
print_header("Setting up VNC")
install_pkg("tigervnc", "lxde-gtk3")
if file_exists("/etc/pam.d/tigervnc.pacnew"):
move("/etc/pam.d/tigervnc.pacnew", "/etc/pam.d/tigervnc")
link_files([
[
SCRIPT_DIR.joinpath("vncserver.users"),
Path("/etc/tigervnc/vncserver.users"),
True,
],
[
SCRIPT_DIR.joinpath("config"),
Path.home().joinpath(".vnc", "config"),
True,
],
])
run_command("sudo systemctl enable vncserver@:1")
run_command("sudo systemctl start vncserver@:1")
def install_zsh_plugin(plugin, remote):
print_line(f"Installing plugin {plugin}")
plugin_dir = zsh_plugin_dir.joinpath(plugin)
if not dir_exists(plugin_dir):
run_command(f"git clone '{remote}' '{plugin_dir}'")
run_command("git pull", cwd=plugin_dir)
def install_homebrew(force=False):
if not platform.is_mac or (not force and command_exists("brew")):
return
print_line("Installing Homebrew")
run_command(
'/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"',
shell=True,
)
def run(self):
if not platform.is_mac:
return
print_header("Setting up macOS Finder")
# Setup Finder to show all files
run_command("defaults write com.apple.finder AppleShowAllFiles YES", shell=True)
run_command(
"killall Finder /System/Library/CoreServices/Finder.app", shell=True
)
def run(self):
print_header("Setting up Minicom")
for file in ["dfl", "fast"]:
link_file(
Path(__file__).parent.joinpath(f".minirc.{file}"),
Path.home().joinpath(f".minirc.{file}"),
)
install_pkg("minicom")
if platform.is_linux:
run_command("sudo usermod -a -G dialout $(whoami)", shell=True)
def run(self):
if not platform.is_arch:
return
print_header("Setting up Pacman")
link_file(SCRIPT_DIR.joinpath("pacman.conf"),
Path("/etc/pacman.conf"),
sudo=True)
install_pkg("reflector", "arch-audit", "kernel-modules-hook")
# Enable kernel module cleanup job
run_command("sudo systemctl daemon-reload")
run_command("sudo systemctl enable linux-modules-cleanup")
# Hooks are symlinked individually to allow local hooks that are
# not managed by this installer.
with os.scandir(SCRIPT_DIR.joinpath("hooks")) as hooks:
hook_dir = "/etc/pacman.d/hooks/"
for item in hooks:
link_file(item.path, Path(hook_dir + item.name), sudo=True)
link_file(
SCRIPT_DIR.joinpath("reflector.conf"),
Path("/etc/xdg/reflector/reflector.conf"),
sudo=True,
)
run_command("sudo systemctl enable reflector.timer")
run_command("sudo systemctl start reflector.timer")
def run(self):
print_header("Install fonts")
os.makedirs(FONT_LIBRARY, exist_ok=True)
reload_font = False
for font in settings["fonts"]:
reload_font = (
install_font(font["remote"], FONT_LIBRARY.joinpath(font["name"]))
or reload_font
)
if reload_font:
print_line("Rescanning font caches")
run_command("fc-cache -r")
def run(self):
print_header("Setting up GPG")
add_zsh_hook(Hook.POST, "10-gpg", SCRIPT_DIR.joinpath("setuphook.zsh"))
add_fish_hook(Hook.POST, "10-gpg",
SCRIPT_DIR.joinpath("setuphook.fish"))
if file_exists(INSTALLED_CANARY) and "force" not in self.args:
print_line("GPG already setup")
return
# Use macOS binary location for consistancy
if not file_exists("/usr/local/bin/gpg2"):
link_file("/usr/bin/gpg2", "/usr/local/bin/gpg2", sudo=True)
self.install_pkgs()
os.makedirs(GNUPG_DIR, exist_ok=True)
link_file(SCRIPT_DIR.joinpath("gpg.conf"),
GNUPG_DIR.joinpath("gpg.conf"))
if platform.is_mac:
link_file(
SCRIPT_DIR.joinpath("gpg-agent.conf"),
GNUPG_DIR.joinpath("gpg-agent.conf"),
)
else:
remove(GNUPG_DIR.joinpath("gpg-agent.conf"))
run_command_no_out(f"chmod -R og-rwx {str(GNUPG_DIR)}")
gpg_key = settings["gpg"]["key"]
print_line(f"GPG Key: {gpg_key}")
# Import my public key and trust it ultimately
if "nokey" not in self.args:
run_command(f"gpg2 --recv-keys {gpg_key}")
trust_key = f"{gpg_key}:6:"
run_command(f"echo '{trust_key}' | gpg2 --import-ownertrust",
shell=True)
if platform.is_fedora and file_exists(
"/etc/xdg/autostart/gnome-keyring-ssh.desktop"):
run_command(
"sudo mv -f /etc/xdg/autostart/gnome-keyring-ssh.desktop /etc/xdg/autostart/gnome-keyring-ssh.desktop.inactive"
)
# Idempotency
run_command('rm -f "$HOME/.gnupg/.dotfile-installed.*"', shell=True)
run_command(f"touch {str(INSTALLED_CANARY)}")
def install_linux_pkgs(self):
if platform.is_fedora:
install_pkg(*self.settings["packages"]["linux"],
*self.settings["packages"]["fedora"])
elif platform.is_ubuntu:
install_pkg(*self.settings["packages"]["linux"],
*self.settings["packages"]["ubuntu"])
elif platform.is_arch:
packmgr.install_aur_helper()
install_pkg(*self.settings["packages"]["linux"],
*self.settings["packages"]["arch"])
run_command("sudo systemctl start haveged")
run_command("sudo systemctl enable haveged")
def install_extensions(self):
print_line("Installing VSCode Extensions", color=Color.MAGENTA)
curr_exts = run_command_no_out(f"{EXE_NAME} --list-extensions")
curr_exts = [
s.lower() for s in curr_exts.stdout.split("\n") if s != ""
]
needed_exts = [
s.lower() for s in settings["vscode"]["extensions"]
if s not in curr_exts
]
for e in needed_exts:
run_command(f"{EXE_NAME} --force --install-extension {e}")
def install_go_pkgs(self):
print_line("Installing/updating Go packages", color=Color.MAGENTA)
for pkg in self.settings["go"]["packages"]:
proc = run_command(f"go get -u '{pkg}'")
if proc.returncode == 0:
print_line(f"Successfully downloaded {pkg}")
def show(self):
"""
Reads content of blob and returns it as a pretty formated output.
"""
level = '{0}:{1}'.format(self.rev, self.path)
file_content = run_command(cmd='git cat-file -p {0}'.format(level), data=None, location=self.repo.location, chw=True)
return file_content
def show(self):
"""
Returns information about commit.
"""
cmd = 'git show {0}'.format(self.sha1_hash)
git_output = run_command(cmd=cmd, data=None, location=self.repo.location, chw=True)
return git_output
def get_committer_name(self):
"""
Returns committer name.
"""
cmd='git log {0} -1 --format="%cn" {1}'.format(self.rev, self.sha1_hash)
git_output = run_command(cmd=cmd, data=None, location=self.repo.location, chw=True).strip()
return git_output
def get_committer_email(self):
"""
Returns committer email.
"""
cmd = 'git log -1 --format="%ce" {0} -- {1}'.format(self.rev, self.path)
git_output = run_command(cmd=cmd, data=None, location=self.repo.location, chw=True).strip()
return git_output
def get_subject(self):
"""
Returns latest commit message given to this commit.
"""
cmd='git log -1 --format="%s" {0}'.format(self.sha1_hash)
git_output = run_command(cmd=cmd, data=None, location=self.repo.location, chw=True).strip()
return git_output
def get_committer_date(self):
"""
Returns latest commiter date for this commit in "ISO 8601-like" format and UTC timezone.
"""
cmd='git log -1 --format="%ci" {0}'.format(self.sha1_hash)
git_output = run_command(cmd=cmd, data=None, location=self.repo.location, chw=True)
return time_to_utc(git_output.strip())
def link_file(src: Path, dest: Path, sudo=False, copy=False):
dest_dir = str(dest.parent)
src = str(src)
dest = str(dest)
# Check if environment overrides copy behavior
if os.getenv("DOT_NO_LINK"):
copy = True
os.makedirs(dest_dir, exist_ok=True)
# Copy or link new file
if copy:
copyfile(src, dest, sudo=sudo)
else:
cmd = f"ln -sfn {shlex.quote(src)} {shlex.quote(dest)}"
if sudo:
cmd = "sudo " + cmd
run_command(cmd)
def setup_cred_store(self):
# Get current config
docker_config = Path.home().joinpath(".docker", "config.json")
with open(docker_config) as f:
config = json.load(f)
# Check if credential store is already configured
if "credsStore" not in config:
install_pkg("docker-credential-secretservice", "gnome-keyring")
config["auths"] = {
} # Reset auths to remove any existing passwords
config["credsStore"] = "secretservice"
# Write out new config, make it pretty
with open(docker_config, "w") as f:
json.dump(config, f, indent=2)
run_command("sudo systemctl restart docker")
def setup_hooks(self):
os.makedirs(home_dir.joinpath(".local.zsh.d", "pre"), exist_ok=True)
os.makedirs(home_dir.joinpath(".local.zsh.d", "post"), exist_ok=True)
os.makedirs(home_dir.joinpath(".local.zsh.d", "paths"), exist_ok=True)
# Convert old custom into new hooks system
# Shouldn't be needed anymore, but just in case
if file_exists(home_dir.joinpath(".local.zsh")):
run_command(
'mv -n "$HOME/.local.zsh" "$HOME/.local.zsh.d/post/00-old-local.zsh"',
shell=True,
)
add_to_path("zsh", home_dir.joinpath("bin"))
add_to_path("zsh", home_dir.joinpath(".scripts"))
add_to_path("zsh", home_dir.joinpath(".local/scripts"))
add_zsh_hook(Hook.POST, "10-vars", script_dir.joinpath("vars.zsh"))
add_zsh_hook(Hook.POST, "10-nnn-setup",
script_dir.joinpath("nnn-setup.zsh"))
def show(self):
"""
Reads content of blob and returns it as a pretty formated output.
"""
level = '{0}:{1}'.format(self.rev, self.path)
file_content = run_command(cmd='git cat-file -p {0}'.format(level),
data=None,
location=self.repo.location,
chw=True)
return file_content
def show(self):
"""
Returns information about commit.
"""
cmd = 'git show {0}'.format(self.sha1_hash)
git_output = run_command(cmd=cmd,
data=None,
location=self.repo.location,
chw=True)
return git_output
def get_subject(self):
"""
Returns latest commit message given to this commit.
"""
cmd = 'git log -1 --format="%s" {0}'.format(self.sha1_hash)
git_output = run_command(cmd=cmd,
data=None,
location=self.repo.location,
chw=True).strip()
return git_output
def get_committer_date(self):
"""
Returns latest commiter date for this commit in "ISO 8601-like" format and UTC timezone.
"""
cmd = 'git log -1 --format="%ci" {0}'.format(self.sha1_hash)
git_output = run_command(cmd=cmd,
data=None,
location=self.repo.location,
chw=True)
return time_to_utc(git_output.strip())
def install_pkgs(self):
if platform.is_mac:
install_pkg("gpg2", "pidof", "pinentry-mac")
elif platform.is_ubuntu:
install_pkg(
"gnupg-agent",
"gnupg2",
"pinentry-gtk2",
"scdaemon",
"libccid",
"pcscd",
"libpcsclite1",
"gpgsm",
)
elif platform.is_fedora:
install_pkg("ykpers", "libyubikey", "gnupg", "gnupg2-smime")
elif platform.is_arch:
install_pkg("gnupg", "pinentry", "ccid", "pcsclite")
run_command("sudo systemctl enable pcscd.service")
run_command("sudo systemctl start pcscd.service")
else:
print_line("Unsupported distribution")
def get_committer_email(self):
"""
Returns committer email.
"""
cmd = 'git log -1 --format="%ce" {0} -- {1}'.format(
self.rev, self.path)
git_output = run_command(cmd=cmd,
data=None,
location=self.repo.location,
chw=True).strip()
return git_output
def get_committer_name(self):
"""
Returns committer name.
"""
cmd = 'git log {0} -1 --format="%cn" {1}'.format(
self.rev, self.sha1_hash)
git_output = run_command(cmd=cmd,
data=None,
location=self.repo.location,
chw=True).strip()
return git_output
def install_aur_helper(force=False):
if not platform.is_arch or (not force and command_exists("yay")):
return
yay_path = Path.home().joinpath("code", "yay")
if yay_path.is_dir():
run_command("git fetch", cwd=yay_path)
else:
makedirs(yay_path.parent, exist_ok=True)
run_command(
f"git clone 'https://aur.archlinux.org/yay-bin.git' {yay_path}")
run_command("makepkg -Acs", cwd=yay_path)
run_command("sudo pacman -U *.pkg.tar", cwd=yay_path, shell=True)
def show(self):
"""
Returns content of tree object which may be other trees or blobs.
"""
level = '{0}:{1}'.format(self.rev, self.path)
cmd = 'git ls-tree --full-tree {0}'.format(level)
git_output = run_command(cmd=cmd, data=None, location=self.repo.location, chw=True).split('\n')[:-1]
tree_contents = []
for item in git_output:
kind, path = item.split()[1], '{0}/{1}'.format(self.path, item.split()[3])
if kind == GIT_BLOB_OBJECT:
tree_contents.append(GitBlob(repo=self.repo, path=path, rev=self.rev))
elif kind == GIT_TREE_OBJECT:
tree_contents.append(GitTree(repo=self.repo, path=path, rev=self.rev))
return tree_contents
def run(self):
print_header("Setting up Generic Configs")
link_file(SCRIPT_DIR.joinpath("scripts"),
HOME_DIR.joinpath(".scripts"))
with os.scandir(SCRIPT_DIR.joinpath("config")) as configs:
config_dir = HOME_DIR.joinpath(".config")
for item in configs:
if item.is_dir():
link_file(item.path, config_dir.joinpath(item.name))
if not platform.is_mac:
run_command("systemctl --user daemon-reload")
run_command("systemctl --user enable newsboat.timer")
run_command("systemctl --user enable random_wallpaper.timer")
if platform.is_arch:
run_command("systemctl --user enable pacupdate.timer")
self.exec_installer("configs/home", "home")
def show(self):
"""
Returns content of tree object which may be other trees or blobs.
"""
level = '{0}:{1}'.format(self.rev, self.path)
cmd = 'git ls-tree --full-tree {0}'.format(level)
git_output = run_command(cmd=cmd,
data=None,
location=self.repo.location,
chw=True).split('\n')[:-1]
tree_contents = []
for item in git_output:
kind, path = item.split()[1], '{0}/{1}'.format(
self.path,
item.split()[3])
if kind == GIT_BLOB_OBJECT:
tree_contents.append(
GitBlob(repo=self.repo, path=path, rev=self.rev))
elif kind == GIT_TREE_OBJECT:
tree_contents.append(
GitTree(repo=self.repo, path=path, rev=self.rev))
return tree_contents
def setup_oh_my_zsh(self):
if dir_exists(omz_dir) and not file_exists(
omz_dir.joinpath("oh-my-zsh.sh")):
os.rmdir(omz_dir)
# oh-my-zsh
if not dir_exists(omz_dir):
print_line("Installing oh-my-zsh")
run_command("bash " +
str(script_dir.joinpath("install-oh-my-zsh.sh")))
if platform.is_mac:
run_command(
'sudo dscl . -create "/Users/${USER}" UserShell /usr/local/bin/zsh',
shell=True,
)
# Update Oh My ZSH
run_command("git pull --rebase --stat origin master", cwd=omz_dir)
def remove(path: Path, sudo=False):
cmd = f"rm -rf {shlex.quote(str(path))}"
if sudo:
cmd = "sudo " + cmd
run_command(cmd)
def check_nvim_installed(self):
if command_exists("nvim"):
return
if platform.is_fedora:
install_pkg("python2-neovim", "python3-neovim")
elif platform.is_ubuntu:
install_apt_ppa("neovim-ppa/stable", update_lists=True)
install_pkg("neovim", "python-dev", "python-pip", "python3-dev",
"python3-pip")
run_command(
"sudo update-alternatives --install /usr/bin/vi vi /usr/bin/nvim 60"
)
run_command("sudo update-alternatives --config vi")
run_command(
"sudo update-alternatives --install /usr/bin/vim vim /usr/bin/nvim 60"
)
run_command("sudo update-alternatives --config vim")
run_command(
"sudo update-alternatives --install /usr/bin/editor editor /usr/bin/nvim 60"
)
run_command("sudo update-alternatives --config editor")
def move(src: Path, dest: Path, sudo=False):
cmd = f"mv {shlex.quote(str(src))} {shlex.quote(str(dest))}"
if sudo:
cmd = "sudo " + cmd
run_command(cmd)
def copyfile(src, dest, sudo=False):
if sudo:
run_command(f"sudo cp {shlex.quote(src)} {shlex.quote(dest)}")
else:
copy(src, dest)
