Just for Fun (Posts about Git)

Some util git script

mgian — Tue, 02 Jul 2024 12:40:06 GMT

So, at work we use a log Git, with many interdependant projects that (often) have some submodules. One of the problems we encounter sometimes is that we need to create a new branch of a project but only of some of the submodules, or we need to branch a couple of projects to do the work.
If the work is long enough, sometime you can lose track of which branch is which project. So in times I wrote some scripts to help myself. They are simple Bash script, probabily adaptable to other shells (Tcsh in in the work), and are something a little more advanced of an command alias.

The main repository is on Codeberg and for now it has only the Bash version (since it what I currently use a work) but they should be easy enough to port them to other shells (Tcsh is planned).

Merging git repositories

mgian — Tue, 02 Feb 2021 21:47:42 GMT

For a project, I decided that can be a good idea to merge a couple of repositories to have a single point where to put all the code, issues, wiki and so on.

I later abandoned the idea, since it not came out as good as I was thinking, but in the end I have done it, so why not to share how to do it ?

The main point was that I'd liked to not lose the commit history of the repos I was merging, so I should find some way to merge even these.

Of course a simple copy of the code does not work, since you loose the commit history.
Luckily git offer a way to do it anyway.

The method I used, and later found in a lot of places so nothing new, is to decide which is the main repository where to add the others and then use the merge command.

Assuming that repoA is the main repository with a project caller ProjectA and repoB is the one I want to add with a project called ProjectB, here is the command to use:

git remote add repoBRemote repoBPath
git fetch repoBRemote
git checkout -b ProjectB repoB/master
mkdir ProjectB
git mv [everything in the procject] ProjectB
git commit -m [commit message]
git checkout master
git merge ProjectB
git commit
git push
git remote rm repoBRemote
git branch -d ProjectB

The end result is a repository with this structure

|
|--- ProjectA
|       |...
|
|--- ProjectB
|       |...

and the commit history of both of them.

Making the MiniBookDB database public take 2

mgian — Wed, 20 Jan 2021 21:48:58 GMT

In the quest to make the MiniBookDb database readable from outside my home network, I tried to use a microservice in Pythn/Flask.
While the approach work, I had the problem that the same site name is resolved with different IP depending on where I am: on my private network the site name is resolved with an private IP, on the outside it is solved as a public IP.

The probem
On my private network, I also run the DNS, so that I can assign a specific IP to MiniBookDB on the Raspberry, so since the site is accessible with the same name both from outside and inside the private network, when the Raspberry call the microservice on the public server, in the end it call itself and fail.

Since I don't want to use different site name, I had to let go the microservice and use another way.

The solution
Remembering how I deploy this site (and the other one) I decide to use git and the old good cron, with some python magic.

The pyhton magic is just a script that execute some simple actions: - extract all the books from the MongoDB, selecting only the needed fields - store them in a SQLite file - generate the HTML files from the SQLite db - commit them to a git repository

Once the file are pushed to the git repository which is on the public server, an hook extract the HTML files and copy them in the correct directory where the site live.

The operation is executed every day at midnight using a cron job on the Raspberry.

All the sensible operations are done on the Raspberry, so inside my private network and I ditched also the need for authentication when calling the microservice, since it is handled by git using the usual ssh key.

The hook on the server is pretty simple, copied and adapted from the one I use for this site.

The result
After the initial problems in the tests, the system work very well. The only downside is that the public pages are update once a day, but that is acceptable.

Deploy Pelican blog with git on Linode

mgian — Sat, 28 Dec 2019 22:02:46 GMT

Ok, now I have a new blog with Pelican on my pc, but how I can deploy it to my remote server on Linode ?

Aside from the two ways already usable from the Makefile you have by default (ssh and rsync), it is possible to deploy also with Git.

Disclaimer

This mini-tutorial is not all mine, I got the informations from various sites and pages, and adapted it to my need. You can find a lot of similar solutions on the Web, many way older than mine. Additionally, I got inspired from the deployment of Hexo.io, another blog generator written in nodejs that I used some time ago, done with a git's hook.

Prerequisites

All you need is a working local Pelican blog, to install it you can follow the Pelican Documentation which explain really well how to do it.

Another thing you need to have is a working Linode's linode with shell access and a working git installation. It is not really important how big.

Step 1

Access your server and create a git repository for your blog

mkdir -p /path/to/your/repo
cd /path/to/your/repo
git init --bare

This create a bare Git repository that will not host any files but only the version control (see the git documentation for more info)

Step 2

In your repository create a hook caller post-receive in the hooks directory of your repository

#!/bin/bash -l
PATH=[your_user_path]
GIT_REPO=/path/to/your/repo
TMP_GIT_CLONE=/tmp/git/your_repo_name
PUBLIC_WWW=/path/to/your/web_root
git clone $GIT_REPO $TMP_GIT_CLONE
cp -a TMP_GIT_CLONE/* PUBLIC_WWW
rm -Rf $TMP_GIT_CLONE
exit

Step 3

In your local Pelican directory, clone your git repository of your blog, with the usual git command git clone [your_user]@your_serve:/path/to/your/repo output

The output at the end is important since it is the directory where Pelican generate your site.

At this point your are ready to deploy your site. You simply need to generate it using one of this ways: * pelican -lr * make html

I use the first option since it start a local server http://localhost:8000 which allow you to see your blog locally with a browser, but also the latest can be used.

Once you have generated the html files for your articles, pages and everything else, you just need to add, commit and push your repo t deploy your site

git add .
git commit -am "First article"
git push

at this point you should see something like this:

Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 8 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 338 bytes | 338.00 KiB/s, done.
Total 3 (delta 2), reused 0 (delta 0)
remote: Cloning into '/tmp/git/devel.grys.it'...
remote: done.
To git.grys.it:/home/git/devel.grys.it
   e6f9934..ec16614  master -> master

which is the message I got for this site. If you get an error, it will be displayed in the message to allow you to solve the problem (permission problem, missing directory, wrong path, whatever)

If no error is reported, congratulation, you just deployed your blog on your server, just open a browser and navigate to it to do a final check.