I have been using my Samsung Galaxy Tab A (2015) with PostmarketOS on and off since last year. It serves as a really good e-book reader with KOReader installed on it.

Have tried phosh and plasma-mobile on it, works nicely but slows the device down heavily (2 GB RAM and old processor) so I use MATE Desktop environment on it.

Lately I have started using this tablet along with my laptop as a second screen for work. And it has been working super nicely for that. The only issue being that I have to manually rotate the screen to landscape every time I reboot the device. It resets the screen orientation to portrait after a reboot. So I went through the pmOS wiki and a neat nice hack documented there worked very well for me.

First we will test if the auto-rotate sensor works and if we can read values from it. So we install some basic necessary packages

$ sudo apk add xrandr xinput inotify-tools iio-sensor-proxy

Enable the service for iio-sensor-proxy

sudo rc-update add iio-sensor-proxy

Reboot the device.

Now in the device terminal start the sensor monitor-sensor

user@samsung-gt58 ~> monitor-sensor
    Waiting for iio-sensor-proxy to appear
+++ iio-sensor-proxy appeared
=== Has accelerometer (orientation: normal, tilt: vertical)
=== Has ambient light sensor (value: 5.000000, unit: lux)
=== No proximity sensor
=== No compass
    Light changed: 14.000000 (lux)
    Accelerometer orientation changed: left-up
    Tilt changed: tilted-down
    Light changed: 12.000000 (lux)
    Tilt changed: vertical
    Light changed: 13.000000 (lux)
    Light changed: 11.000000 (lux)
    Light changed: 13.000000 (lux)
    Accelerometer orientation changed: normal
    Light changed: 5.000000 (lux)
    Light changed: 6.000000 (lux)
    Light changed: 5.000000 (lux)
    Accelerometer orientation changed: right-up
    Light changed: 3.000000 (lux)
    Light changed: 4.000000 (lux)
    Light changed: 5.000000 (lux)
    Light changed: 12.000000 (lux)
    Tilt changed: tilted-down
    Light changed: 19.000000 (lux)
    Accelerometer orientation changed: bottom-up
    Tilt changed: vertical
    Light changed: 1.000000 (lux)
    Light changed: 2.000000 (lux)
    Light changed: 4.000000 (lux)
    Accelerometer orientation changed: right-up
    Tilt changed: tilted-down
    Light changed: 11.000000 (lux)
    Accelerometer orientation changed: normal
    Tilt changed: vertical
    Tilt changed: tilted-down
    Light changed: 18.000000 (lux)
    Light changed: 21.000000 (lux)
    Light changed: 22.000000 (lux)
    Light changed: 19.000000 (lux)
    Accelerometer orientation changed: left-up
    Light changed: 17.000000 (lux)
    Tilt changed: vertical
    Light changed: 14.000000 (lux)
    Tilt changed: tilted-down
    Light changed: 16.000000 (lux)
    Light changed: 18.000000 (lux)
    Light changed: 17.000000 (lux)
    Light changed: 18.000000 (lux)
    Light changed: 17.000000 (lux)
    Light changed: 18.000000 (lux)
    Light changed: 17.000000 (lux)
    Light changed: 18.000000 (lux)
    Light changed: 17.000000 (lux)

As you can see we can read the rotation values from the sensor as I am rotating the tablet in different orientations.

Now we just need to use a script which changes the screen orientation using xrandr according to the sensor value.

#!/bin/sh
killall monitor-sensor
monitor-sensor > /dev/shm/sensor.log 2>&1 &
while inotifywait -e modify /dev/shm/sensor.log; do
  ORIENTATION=$(tail /dev/shm/sensor.log | grep 'orientation' | tail -1 | grep -oE '[^ ]+$')
  case "$ORIENTATION" in
    normal)
      xrandr -o normal
      xinput set-prop "Goodix Capacitive TouchScreen" "Coordinate Transformation Matrix" 1 0 0 0 1 0 0 0 1
      ;;
    left-up)
      xrandr -o left
      xinput set-prop "Goodix Capacitive TouchScreen" "Coordinate Transformation Matrix" 0 -1 1 1 0 0 0 0 1
      ;;
    bottom-up)
      xrandr -o inverted
      xinput set-prop "Goodix Capacitive TouchScreen" "Coordinate Transformation Matrix" -1 0 1 0 -1 1 0 0 1
      ;;
    right-up)
      xrandr -o right
      xinput set-prop "Goodix Capacitive TouchScreen" "Coordinate Transformation Matrix" 0 1 0 -1 0 1 0 0 1
      ;;
  esac
done

You need to replace the name of your touch input device in the script, you can get the name by using xinput --list , make sure to type this on the device terminal.

user@samsung-gt58 ~> xinput --list
* Virtual core pointer                    	id=2	[master pointer  (3)]
*   * Virtual core XTEST pointer              	id=4	[slave  pointer  (2)]
*   * Zinitix Capacitive TouchScreen          	id=10	[slave  pointer  (2)]
*   * Toad One Plus                           	id=12	[slave  pointer  (2)]
* Virtual core keyboard                   	id=3	[master keyboard (2)]
    * Virtual core XTEST keyboard             	id=5	[slave  keyboard (3)]
    * GPIO Buttons                            	id=6	[slave  keyboard (3)]
    * pm8941_pwrkey                           	id=7	[slave  keyboard (3)]
    * pm8941_resin                            	id=8	[slave  keyboard (3)]
    * Zinitix Capacitive TouchScreen          	id=11	[slave  keyboard (3)]
    * samsung-a2015 Headset Jack              	id=9	[slave  keyboard (3)]

In our script here we are using a Zinitix capacitive screen, it will be different for yours.

Once your script is ready with the correct touchscreen name. Save and make the script executable. chmod +x auto-rotate-screen.sh

Then test your script in your terminal ./auto-rotate.sh , stop the script using Ctrl + C

Now we need add this script to auto-start. On MATE DE you can go to System > Control Center > Startup Applications, then click on Custom Add button, browse the script location, give it a name and then click on Add button.

Now reboot the tablet/device, login and see the auto rotation working.

1. Auto-Rotation wiki article on PostmarketOS Wiki https://wiki.postmarketos.org/wiki/Auto-rotation

Nextcloud is a popular self-hosted solution for file sync and share as well as cloud apps such as document editing, chat and talk, calendar, photo gallery etc. This guide will walk you through setting up Nextcloud AIO using Docker Compose.

This blog post would not be possible without immense help from Sahil Dhiman a.k.a. sahilister

There are various ways in which the installation could be done, in our setup here are the pre-requisites.

• A server with docker-compose installed
• An existing setup of nginx reverse proxy
• A domain name pointing to your server.

Step 1 : The docker-compose file for nextcloud AIO

The original compose.yml file is present in nextcloud AIO's git repo here . By taking a reference of that file, we have own compose.yml here.

services:
  nextcloud-aio-mastercontainer:
    image: nextcloud/all-in-one:latest
    init: true
    restart: always
    container_name: nextcloud-aio-mastercontainer # This line is not allowed to be changed as otherwise AIO will not work correctly
    volumes:
      - nextcloud_aio_mastercontainer:/mnt/docker-aio-config # This line is not allowed to be changed as otherwise the built-in backup solution will not work
      - /var/run/docker.sock:/var/run/docker.sock:ro # May be changed on macOS, Windows or docker rootless. See the applicable documentation. If adjusting, don't forget to also set 'WATCHTOWER_DOCKER_SOCKET_PATH'!
    ports:
      - 8080:8080
    environment: # Is needed when using any of the options below
      # - AIO_DISABLE_BACKUP_SECTION=false # Setting this to true allows to hide the backup section in the AIO interface. See https://github.com/nextcloud/all-in-one#how-to-disable-the-backup-section
      - APACHE_PORT=32323 # Is needed when running behind a web server or reverse proxy (like Apache, Nginx, Cloudflare Tunnel and else). See https://github.com/nextcloud/all-in-one/blob/main/reverse-proxy.md
      - APACHE_IP_BINDING=127.0.0.1 # Should be set when running behind a web server or reverse proxy (like Apache, Nginx, Cloudflare Tunnel and else) that is running on the same host. See https://github.com/nextcloud/all-in-one/blob/main/reverse-proxy.md
      # - BORG_RETENTION_POLICY=--keep-within=7d --keep-weekly=4 --keep-monthly=6 # Allows to adjust borgs retention policy. See https://github.com/nextcloud/all-in-one#how-to-adjust-borgs-retention-policy
      # - COLLABORA_SECCOMP_DISABLED=false # Setting this to true allows to disable Collabora's Seccomp feature. See https://github.com/nextcloud/all-in-one#how-to-disable-collaboras-seccomp-feature
      - NEXTCLOUD_DATADIR=/opt/docker/cloud.raju.dev/nextcloud # Allows to set the host directory for Nextcloud's datadir. ⚠️⚠️⚠️ Warning: do not set or adjust this value after the initial Nextcloud installation is done! See https://github.com/nextcloud/all-in-one#how-to-change-the-default-location-of-nextclouds-datadir
      # - NEXTCLOUD_MOUNT=/mnt/ # Allows the Nextcloud container to access the chosen directory on the host. See https://github.com/nextcloud/all-in-one#how-to-allow-the-nextcloud-container-to-access-directories-on-the-host
      # - NEXTCLOUD_UPLOAD_LIMIT=10G # Can be adjusted if you need more. See https://github.com/nextcloud/all-in-one#how-to-adjust-the-upload-limit-for-nextcloud
      # - NEXTCLOUD_MAX_TIME=3600 # Can be adjusted if you need more. See https://github.com/nextcloud/all-in-one#how-to-adjust-the-max-execution-time-for-nextcloud
      # - NEXTCLOUD_MEMORY_LIMIT=512M # Can be adjusted if you need more. See https://github.com/nextcloud/all-in-one#how-to-adjust-the-php-memory-limit-for-nextcloud
      # - NEXTCLOUD_TRUSTED_CACERTS_DIR=/path/to/my/cacerts # CA certificates in this directory will be trusted by the OS of the nexcloud container (Useful e.g. for LDAPS) See See https://github.com/nextcloud/all-in-one#how-to-trust-user-defined-certification-authorities-ca
      # - NEXTCLOUD_STARTUP_APPS=deck twofactor_totp tasks calendar contacts notes # Allows to modify the Nextcloud apps that are installed on starting AIO the first time. See https://github.com/nextcloud/all-in-one#how-to-change-the-nextcloud-apps-that-are-installed-on-the-first-startup
      # - NEXTCLOUD_ADDITIONAL_APKS=imagemagick # This allows to add additional packages to the Nextcloud container permanently. Default is imagemagick but can be overwritten by modifying this value. See https://github.com/nextcloud/all-in-one#how-to-add-os-packages-permanently-to-the-nextcloud-container
      # - NEXTCLOUD_ADDITIONAL_PHP_EXTENSIONS=imagick # This allows to add additional php extensions to the Nextcloud container permanently. Default is imagick but can be overwritten by modifying this value. See https://github.com/nextcloud/all-in-one#how-to-add-php-extensions-permanently-to-the-nextcloud-container
      # - NEXTCLOUD_ENABLE_DRI_DEVICE=true # This allows to enable the /dev/dri device in the Nextcloud container. ⚠️⚠️⚠️ Warning: this only works if the '/dev/dri' device is present on the host! If it should not exist on your host, don't set this to true as otherwise the Nextcloud container will fail to start! See https://github.com/nextcloud/all-in-one#how-to-enable-hardware-transcoding-for-nextcloud
      # - NEXTCLOUD_KEEP_DISABLED_APPS=false # Setting this to true will keep Nextcloud apps that are disabled in the AIO interface and not uninstall them if they should be installed. See https://github.com/nextcloud/all-in-one#how-to-keep-disabled-apps
      # - TALK_PORT=3478 # This allows to adjust the port that the talk container is using. See https://github.com/nextcloud/all-in-one#how-to-adjust-the-talk-port
      # - WATCHTOWER_DOCKER_SOCKET_PATH=/var/run/docker.sock # Needs to be specified if the docker socket on the host is not located in the default '/var/run/docker.sock'. Otherwise mastercontainer updates will fail. For macos it needs to be '/var/run/docker.sock'
    # networks: # Is needed when you want to create the nextcloud-aio network with ipv6-support using this file, see the network config at the bottom of the file
      # - nextcloud-aio # Is needed when you want to create the nextcloud-aio network with ipv6-support using this file, see the network config at the bottom of the file
      # - SKIP_DOMAIN_VALIDATION=true
    # # Uncomment the following line when using SELinux
    # security_opt: ["label:disable"]
volumes: # If you want to store the data on a different drive, see https://github.com/nextcloud/all-in-one#how-to-store-the-filesinstallation-on-a-separate-drive
  nextcloud_aio_mastercontainer:
    name: nextcloud_aio_mastercontainer # This line is not allowed to be changed as otherwise the built-in backup solution will not work

I have not removed many of the commented options in the compose file, for a possibility of me using them in the future.

If you want a smaller cleaner compose with the extra options, you can refer to

services:
  nextcloud-aio-mastercontainer:
    image: nextcloud/all-in-one:latest
    init: true
    restart: always
    container_name: nextcloud-aio-mastercontainer
    volumes:
      - nextcloud_aio_mastercontainer:/mnt/docker-aio-config
      - /var/run/docker.sock:/var/run/docker.sock:ro
    ports:
      - 8080:8080
    environment:
      - APACHE_PORT=32323
      - APACHE_IP_BINDING=127.0.0.1
      - NEXTCLOUD_DATADIR=/opt/docker/nextcloud
volumes:
  nextcloud_aio_mastercontainer:
    name: nextcloud_aio_mastercontainer

I am using a separate directory to store nextcloud data. As per nextcloud documentation you should be using a separate partition if you want to use this feature, however I did not have that option on my server, so I used a separate directory instead.

Also we use a custom port on which nextcloud listens for operations, we have set it up as 32323 above, but you can use any in the permissible port range. The 8080 port is used the setup the AIO management interface. Both 8080 and the APACHE_PORT do not need to be open on the host machine, as we will be using reverse proxy setup with nginx to direct requests.

once you have your preferred compose.yml file, you can start the containers using

$ docker-compose -f compose.yml up -d 
Creating network "clouddev_default" with the default driver
Creating volume "nextcloud_aio_mastercontainer" with default driver
Creating nextcloud-aio-mastercontainer ... done

once your container's are running, we can do the nginx setup.

Step 2: Configuring nginx reverse proxy for our domain on host.

A reference nginx configuration for nextcloud AIO is given in the nextcloud git repository here . You can modify the configuration file according to your needs and setup.

Here is configuration that we are using

map $http_upgrade $connection_upgrade {
    default upgrade;
    '' close;
}
server {
    listen 80;
    #listen [::]:80;            # comment to disable IPv6
    if ($scheme = "http") {
        return 301 https://$host$request_uri;
    }
    listen 443 ssl http2;      # for nginx versions below v1.25.1
    #listen [::]:443 ssl http2; # for nginx versions below v1.25.1 - comment to disable IPv6
    # listen 443 ssl;      # for nginx v1.25.1+
    # listen [::]:443 ssl; # for nginx v1.25.1+ - keep comment to disable IPv6
    # http2 on;                                 # uncomment to enable HTTP/2        - supported on nginx v1.25.1+
    # http3 on;                                 # uncomment to enable HTTP/3 / QUIC - supported on nginx v1.25.0+
    # quic_retry on;                            # uncomment to enable HTTP/3 / QUIC - supported on nginx v1.25.0+
    # add_header Alt-Svc 'h3=":443"; ma=86400'; # uncomment to enable HTTP/3 / QUIC - supported on nginx v1.25.0+
    # listen 443 quic reuseport;       # uncomment to enable HTTP/3 / QUIC - supported on nginx v1.25.0+ - please remove "reuseport" if there is already another quic listener on port 443 with enabled reuseport
    # listen [::]:443 quic reuseport;  # uncomment to enable HTTP/3 / QUIC - supported on nginx v1.25.0+ - please remove "reuseport" if there is already another quic listener on port 443 with enabled reuseport - keep comment to disable IPv6
    server_name cloud.example.com;
    location / {
        proxy_pass https://127.0.0.1:32323$request_uri;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Port $server_port;
        proxy_set_header X-Forwarded-Scheme $scheme;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header Accept-Encoding "";
        proxy_set_header Host $host;
    
        client_body_buffer_size 512k;
        proxy_read_timeout 86400s;
        client_max_body_size 0;
        # Websocket
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
    }
    ssl_certificate /etc/letsencrypt/live/cloud.example.com/fullchain.pem; # managed by Certbot
    ssl_certificate_key /etc/letsencrypt/live/cloud.example.com/privkey.pem; # managed by Certbot
    ssl_session_timeout 1d;
    ssl_session_cache shared:MozSSL:10m; # about 40000 sessions
    ssl_session_tickets off;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:DHE-RSA-CHACHA20-POLY1305;
    ssl_prefer_server_ciphers on;
    # Optional settings:
    # OCSP stapling
    # ssl_stapling on;
    # ssl_stapling_verify on;
    # ssl_trusted_certificate /etc/letsencrypt/live/<your-nc-domain>/chain.pem;
    # replace with the IP address of your resolver
    # resolver 127.0.0.1; # needed for oscp stapling: e.g. use 94.140.15.15 for adguard / 1.1.1.1 for cloudflared or 8.8.8.8 for google - you can use the same nameserver as listed in your /etc/resolv.conf file
}

Please note that you need to have valid SSL certificates for your domain for this configuration to work. Steps on getting valid SSL certificates for your domain are beyond the scope of this article. You can give a web search on getting SSL certificates with letsencrypt and you will get several resources on that, or may write a blog post on it separately in the future.

once your configuration for nginx is done, you can test the nginx configuration using

$ sudo nginx -t 
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

and then reload nginx with

$ sudo nginx -s reload

Step 3: Setup of Nextcloud AIO from the browser.

To setup nextcloud AIO, we need to access it using the web browser on URL of our domain.tld:8080, however we do not want to open the 8080 port publicly to do this, so to complete the setup, here is a neat hack from sahilister

ssh -L 8080:127.0.0.1:8080 username@<server-ip>

you can bind the 8080 port of your server to the 8080 of your localhost using Unix socket forwarding over SSH.

The port forwarding only last for the duration of your SSH session, if the SSH session breaks, your port forwarding will to.

So, once you have the port forwarded, you can open the nextcloud AIO instance in your web browser at 127.0.0.1:8080

you will get this error because you are trying to access a page on localhost over HTTPS. You can click on advanced and then continue to proceed to the next page. Your data is encrypted over SSH for this session as we are binding the port over SSH.

Depending on your choice of browser, the above page might look different.

once you have proceeded, the nextcloud AIO interface will open and will look something like this.

It will show an auto generated passphrase, you need to save this passphrase and make sure to not loose it. For the purposes of security, I have masked the passwords with capsicums.

once you have noted down your password, you can proceed to the Nextcloud AIO login, enter your password and then login.

If for some reasons you lose the initial password screen and did not note your password. You can get the initial password by running this on the server

sudo docker exec nextcloud-aio-mastercontainer grep password /mnt/docker-aio-config/data/configuration.json

so now once you have the password, you can click on the open nextcloud AIO login button and enter using the password.

After login you will be greeted with a screen like this.

now you can put the domain that you want to use in the Submit domain field. Once the domain check is done, you will proceed to the next step and see another screen like this

here you can select any optional containers for the features that you might want.

IMPORTANT: Please make sure to also change the time zone at the bottom of the page according to the time zone you wish to operate in.

The timezone setup is also important because the data base will get initialized according to the set time zone. This could result in wrong initialization of database and you ending up in a startup loop for nextcloud. I faced this issue and could only resolve it after getting help from sahilister .

Once you are done changing the timezone, and selecting any additional features you want, you can click on Download and start the containers

It will take some time for this process to finish, take a break and look at the farthest object in your room and take a sip of water. Once you are done, and the process has finished you will see a page similar to the following one.

wait patiently for everything to turn green.

once all the containers have started properly, you can open the nextcloud login interface on your configured domain, the initial login details are auto generated as you can see from the above screenshot. Again you will see a password that you need to note down or save to enter the nextcloud interface. Capsicums will not work as passwords. I have masked the auto generated passwords using capsicums.

Now you can click on Open your Nextcloud button or go to your configured domain to access the login screen.

You can use the login details from the previous step to login to the administrator account of your Nextcloud instance.

There you have it, your very own cloud!

Additional Notes:

How to properly reset Nextcloud setup?

While following the above steps, or while following steps from some other tutorial, you may have made a mistake, and want to start everything again from scratch. The instructions for it are present in the Nextcloud documentation here . Here is the TLDR for a docker-compose setup. These steps will delete all data, do not use these steps on an existing nextcloud setup unless you know what you are doing.

• Stop your master container.

docker-compose -f compose.yml down -v

The above command will also remove the volume associated with the master container

• Stop all the child containers that has been started by the master container.

docker stop nextcloud-aio-apache nextcloud-aio-notify-push nextcloud-aio-nextcloud nextcloud-aio-imaginary nextcloud-aio-fulltextsearch nextcloud-aio-redis nextcloud-aio-database nextcloud-aio-talk nextcloud-aio-collabora

• Remove all the child containers that has been started by the master container

docker rm nextcloud-aio-apache nextcloud-aio-notify-push nextcloud-aio-nextcloud nextcloud-aio-imaginary nextcloud-aio-fulltextsearch nextcloud-aio-redis nextcloud-aio-database nextcloud-aio-talk nextcloud-aio-collabora

• If you also wish to remove all images associated with nextcloud you can do it with

docker rmi $(docker images --filter "reference=nextcloud/*" -q)

• remove all volumes associated with child containers

docker volume rm <volume-name>

• remove the network associated with nextcloud

docker network rm nextcloud-aio

Additional references.

1. Nextcloud Github
2. Nextcloud reverse proxy documentation
3. Nextcloud Administration Guide
4. Nextcloud User Manual
5. Nextcloud Developer's manual

Today I want to introduce you all to f-droid.org

It is an Android app store which only lists free and open source Android apps

In the world of mobile applications, the term "freedom" often takes a back seat to convenience. However, for those who value transparency, privacy, and the ability to customize their digital experience, there's a hidden gem waiting to be explored: F-Droid.

What is F-Droid?

F-Droid is not just another app store; it's a hub of freedom and open-source goodness for Android users. While mainstream app stores may prioritize commercial applications, F-Droid is a haven for those who prefer software that respects user privacy, offers complete transparency, and is built on the principles of open-source development.

Why F-Droid?

1. Open Source Philosophy: Every app available on F-Droid is open-source, meaning its source code is freely available to the public. This not only fosters transparency but also allows users to understand how the app works and even contribute to its development if they have the skills.
2. Privacy First: F-Droid focuses on privacy-centric apps, ensuring that your personal data remains in your hands. No unnecessary permissions or hidden trackers - just apps designed with your privacy in mind.
3. Community-Driven: F-Droid is a community-driven platform maintained by volunteers passionate about open-source software. The apps available are curated to meet strict criteria, guaranteeing quality and security.

Getting Started with F-Droid:

Download the F-Droid App: Begin your journey by downloading the F-Droid app from the official website f-droid.org.

1. Explore the Repository: Once installed, the F-Droid app becomes your gateway to a plethora of open-source apps. Browse categories, discover new tools, and find alternatives to proprietary applications.
2. Install with Confidence: Installing apps from F-Droid is a breeze. With just a few taps, you can enjoy the benefits of high-quality, open-source software on your Android device.

Conclusion:

If you're someone who values freedom, privacy, and the collaborative spirit of open-source development, F-Droid is your ticket to a world of incredible Android apps. Say goodbye to unnecessary permissions, hidden data harvesting, and closed-source mysteries. Embrace F-Droid and discover a new era of mobile app exploration.

Your device, your rules, your freedom.

Hyprland is dynamic tiling Wayland compositor based on wlroots.

It is an interesting new project that caught my eye because of looking at some eye candy desktop setups on Unixporn

I have tried multiple window managers and desktop environments, but I keep falling back to i3wm because of my muscle memory fixed to its key bindings and anything else feels limiting.

However I met Vysakh at DebConf23 and he asked me to give another try to Hyprland.

Vysakh sent me an easy setup script for setting up Hyprland on Debian

It's located at https://github.com/Senshi111/debian-hyprland-hyprdots

using the script did not go smoothly because the during the compilation pkgconfig was getting the wrong version of wayland-protocols package.

While debian has version 1.32, the build was taking 1.24 and my builds were failing because of an older version number.

Some of my issues and there solution are also mentioned in the issue here.

Vysakh debugged the issue along with me for over 3 hours and we finally found that the issue was gnome-core used by some of the apps that I used with snaps. For some reason value of version of wayland-protocols was being supplied by the snap instead of my locally installed native package.

After removing the snap packages, the builds went fine and I had a running hyprland desktop.

And it is awesome!

probably I will switch from i3wm this time.

Install apt-cacher-ng on the host machine

sudo apt install apt-cacher-ng

Check if your apt-cacher-ng service is running by visiting localhost:3142 in your web browser

Check the ip your local docker0 interface

> ip a
....
5: docker0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:60:c7:b6:6b brd ff:ff:ff:ff:ff:ff
    inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
       valid_lft forever preferred_lft forever
    inet6 fe80::42:60ff:fec7:b66b/64 scope link 
       valid_lft forever preferred_lft forever
...

Provide the apt-cacher-ng service URL to your apt-based Dockerfile builds

In your Dockerfile builds use the proxy url for apt-cacher-ng by inserting this additional line

RUN echo 'Acquire::http { Proxy "https://172.17.0.1:3142"; };' >> /etc/apt/apt.conf.d/01proxy

This will work with any operating system base images whose repository system is supported by apt-cacher-ng. More details on apt-cacher-ng website

This is <site/>, a brand new site by rajudev that's just getting started. Things will be up and running here shortly, but you can subscribe in the meantime if you'd like to stay up to date and receive emails when new content is published!

JBOSS Cluster Setup

As per the documentation available for JBOSS on Red Hat’s website

"Red Hat JBoss Enterprise Application Platform 7 (JBoss EAP) is a middleware platform built on open standards and compliant with the Java Enterprise Edition 7 specification."

Think of it as the the plumbing between your application and the server on which it is hosted.

"JBoss EAP provides two operating modes for JBoss EAP instances: standalone server or managed domain. The standalone server operating mode represents running JBoss EAP as a single server instance. The managed domain operating mode allows for the management of multiple JBoss EAP instances from a single control point. "

"In addition, JBoss EAP includes APIs and development frameworks for quickly developing secure and scalable Java EE applications. "

In other words, you deploy a website on a web server, similarly, you deploy a Java Web application on a application server such as JBOSS.

In this blog post, we will setup the application server JBOSS cluster with 2 nodes and deploy a demo application on top of it. For the two nodes of JBOSS you can use any of the machines available to you. I have done this using Vagrant as well as Docker. For the scope of this blog post I will be using Docker. If you have a powerful machine, Vagrant will be easy to use as well.

Here is a simple architecture diagram of a 2 node cluster setup.

In the architecture diagram above I am using the terms Leader for the main node and follower for the sub domain node. Consider this similar to master and slave terminologies, I am avoiding those terminologies because of this

Step I : Prepare the Machines/Containers

We are starting two Docker containers as you can see in the terminal. In the terminal on top we are creating the container for the leader node. And in the second container we are starting the container for the follower node. Break down of the commands entered are as follows.

docker run -it --name="leader" -p 9990:9990 -p 8000:80 centos

docker run Run a docker container

-it In interactive mode and allocate a psedo tty to it.

–name=”leader” assign the name leader to it.

-p 9990:9990 -p 8000:80 expose the external host machines port 9990 to the containers internal 9990 port, similarly for the 8000 port number of the host to the 80 port number of the container.

centos the image name that we have to make the container of, in our case centos.

docker run -it --name="follower" -p 9991:9990 -p 8001:80 centos

In case of the second prompt we are creating the container for the follower that is slave node. Hence the name is different.

Notice that we have incremented the host port numbers, as the port numbers will get used by the leader container, we will need different port numbers for the follower node. So in my case I have incremented the port numbers by 1.

after executing the above commands you will have two containers one above another, ready for our implementation.

For the duration of the tutorial, I will be executing commands for leader in the top terminal and the commands for the follower in the bottom terminal.

Lets move to step II

Step II - Preparing the machines, installing prerequisites

JBOSS requires a few softwares to work such as java. also we would require some softwares to work properly on the container such as a text editor, a network management tool etc. Let install all these dependencies and required software.

Also note that, although CentOS uses yum as the package manager, as a personal preference I use dnf as the package manager. So lets first install dnf.

ppWe execute the following commands on both the leader and follower containers.

yum install dnf -y

After installing the dnf package manager, lets install other packages using dnf.

dnf install java nano emacs sudo java unzip java-1.8.0-openjdk java-1.8.0-openjdk-devel openssh-clients -y

Although we can do most stuff being a root user. I prefer not using the root user at all times. So lets add another user to the containers, make them administrators, set a password for them, and switch to that user.

**On leader **

adduser leader
usermod -aG wheel leader
passwd leader
su leader

**On follower **

adduser follower
usermod -aG wheel follower
passwd follower
su follower

Step III - Download JBOSS

Now lets download JBOSS setup on both of our containers.

The JBoss EAP ZIP file is available from the Red Hat Customer Portal.

Downloading the JBoss EAP ZIP File

• Open a browser and log in to the Red Hat Customer Portal at https://access.redhat.com.
• Click Downloads.
• Click Red Hat JBoss Enterprise Application Platform in the Product Downloads list.
• Select the correct JBoss EAP version from the Version drop-down menu.
• Find Red Hat JBoss Enterprise Application Platform 7.x.x in the list and click the Download link.

You might be required to sign up to the portal or do the provide us some information shenanigans before you could get access to the download. But you will reach to it anyways. Once you get the zip transfer them to the container using scp, or else once you get the link, download it directly inside the container using wget.

Installing the Downloaded zipfile.

Unzip the JBOSS zip

unzip jboss-eap-7.2.0.zip
cd jboss-eap-7.2.0

after doing this my leader and follower terminals look like this.

Step V - Run JBOSS

Step VI - JBOSS Management Interface overview

I have been using git for a while now in my workflow. I find my self proficient enough with git to perform most of the usual tasks involved in the version control management systems.

But recently I decided to dive deep and finish one of the tasks in my bucket list, i.e. mastering git in depth. I planned to do this by reading the Pro Git book written by Scott Chacon & Ben Straub. The book is available to read online at git-scm.com

In this blog post I will be writing the facts and tricks I learned from the book. Following are my take aways from the book.

1. The checksum that we see in git commits is 40 hexadecimal characters

The mechanism that Git uses for this check summing is called a SHA-1 hash. This is a 40-character string composed of hexadecimal characters (0–9 and a–f) and calculated based on the contents of a file or directory structure in Git. A SHA-1 hash looks something like this:

24b9da6552252987aa493b52f8696cd6d3b00373

You will see these hash values all over the place in Git because it uses them so much. In fact, Git stores everything in its database not by file name but by the hash value of its contents.

2. You can clone a git repository under a different folder name

If you want to clone the git repository into a directory named something other than what the repository name uses, you can specify the new directory name as an additional argument:

Syntax

$ git clone <base-URL/repository-name> new-folder-name

Example

$ git clone https://github.com/libgit2/libgit2 mylibgit

3. Apart from the usual git:// and https:// protocols git can also clone a repo from another computer.

Git has a number of different transfer protocols you can use. Most people use https://  or git:// , but you can also clone repos from another machine.

$ git clone user@server:path/to/repo.git

This uses the SSH transfer protocol.

4. Short Git status

While the git status output is pretty comprehensive, it’s also quite wordy. Git also has a short status flag so you can see your changes in a more compact way. If you run git status -s or git status –short you get a far more simplified output from the command:

$ git status -s
 M README
MM Rakefile
A  lib/git.rb
M  lib/simplegit.rb
?? LICENSE.txt

New files that aren’t tracked have a ?? next to them, new files that have been added to the staging area have an A, modified files have an M and so on.

5. Awesome git log

By default, with no arguments, git log lists the commits made in that repository in reverse chronological order. A huge number and variety of options to the git log command are available to show you exactly what you’re looking for. Here, I’ll show some of the most useful ones.

1 . git log --patch or git log -p

Shows the difference (the patch output) introduced in each commit. You can also limit the number of log entries to be displayed by supplying the number in front of the command, such as git log –patch -2

  $ git log -p -2
  commit ca82a6dff817ec66f44342007202690a93763949
  Author: Scott Chacon <schacon@gee-mail.com>
  Date:   Mon Mar 17 21:52:11 2008 -0700
      changed the version number
p
  diff --git a/Rakefile b/Rakefile
  index a874b73..8f94139 100644
  --- a/Rakefile
  +++ b/Rakefile
  @@ -5,7 +5,7 @@ require 'rake/gempackagetask'
  spec = Gem::Specification.new do |s|
      s.platform  =   Gem::Platform::RUBY
      s.name      =   "simplegit"
  -    s.version   =   "0.1.0"
  +    s.version   =   "0.1.1"
      s.author    =   "Scott Chacon"
      s.email     =   "schacon@gee-mail.com"
      s.summary   =   "A simple gem for using Git in Ruby code."
  commit 085bb3bcb608e1e8451d4b2432f8ecbe6306e7e7
  Author: Scott Chacon <schacon@gee-mail.com>
  Date:   Sat Mar 15 16:40:33 2008 -0700
      removed unnecessary test
  diff --git a/lib/simplegit.rb b/lib/simplegit.rb
  index a0a60ae..47c6340 100644
  --- a/lib/simplegit.rb
  +++ b/lib/simplegit.rb
  @@ -18,8 +18,3 @@ class SimpleGit
      end
  end
  -
  -if $0 == __FILE__
  -  git = SimpleGit.new
  -  puts git.show
  -end

2 . git log --stat

If you want to see some abbreviated stats for each commit, you can use the --stat option:

   $ git log --stat
   commit ca82a6dff817ec66f44342007202690a93763949
   Author: Scott Chacon <schacon@gee-mail.com>
   Date:   Mon Mar 17 21:52:11 2008 -0700
       changed the version number
   Rakefile | 2 +-
   1 file changed, 1 insertion(+), 1 deletion(-)
   commit 085bb3bcb608e1e8451d4b2432f8ecbe6306e7e7
   Author: Scott Chacon <schacon@gee-mail.com>
   Date:   Sat Mar 15 16:40:33 2008 -0700
       removed unnecessary test
   lib/simplegit.rb | 5 -----
   1 file changed, 5 deletions(-)
   commit a11bef06a3f659402fe7563abf99ad00de2209e6
   Author: Scott Chacon <schacon@gee-mail.com>
   Date:   Sat Mar 15 10:31:28 2008 -0700
       first commit
   README           |  6 ++++++
   Rakefile         | 23 +++++++++++++++++++++++
   lib/simplegit.rb | 25 +++++++++++++++++++++++++
   3 files changed, 54 insertions(+)

3 . git log --pretty=oneline

This option changes the log output to formats other than the default. A few prebuilt options are available for you to use. The oneline option prints each commit on a single line, which is useful if you’re looking at a lot of commits. In addition, the short, full, and fuller options show the output in roughly the same format but with less or more information, respectively:

   $ git log --pretty=oneline
   ca82a6dff817ec66f44342007202690a93763949 changed the version number
   085bb3bcb608e1e8451d4b2432f8ecbe6306e7e7 removed unnecessary test
   a11bef06a3f659402fe7563abf99ad00de2209e6 first commit

This would be a series of blog posts as I keep reading and discovering more about git through the Pro Git Book   more awesome git tricks would be coming soon in the next part of this blog.

Till then, ciao!

Often at times you want to know the passwords of a particular WiFi connection that you are connected to or of one that you connected in the past.

Where the wifi network details are saved?

The instructions that I am going to write apply to most distributions and the ones which use the network-manager package for managing the networks.

The Wifi networks you have ever connected to are stored in /etc/NetworkManager/system-connections

root@sanganak:/etc/NetworkManager/system-connections# pwd
/etc/NetworkManager/system-connections

This is where all the wifi network details are stored. Lets see some saved networks from my computer.

root@sanganak:/etc/NetworkManager/system-connections# ls -la
total 36
drwxr-xr-x 2 root root 4096 Aug 23 16:51  .
drwxr-xr-x 7 root root 4096 Aug 15 02:57  ..
-rw------- 1 root root  335 Aug 22 00:45  Aryan
-rw------- 1 root root  338 Aug 18 13:07  GUEST-N
-rw------- 1 root root  345 Aug 23 16:51  TBSWPRO
-rw------- 1 root root  343 Aug 23 10:16  TP-LINK
-rw------- 1 root root  343 Aug 19 22:54  Tenda_3563
-rw------- 1 root root  341 Aug 19 14:25  hotspot2
-rw------- 1 root root  384 Aug 19 22:41 ''$'\340\244\270\340\245\207\340\244\265\340\244\276'

When we connect to any wifi network using the GUI of Network Manager or any command line interface. The network details are stored in this particular path with a new file each time corresponding to the SSID of the network.

You can open any of these files and the network details would be right there.

Lets take a look at the network details of GUEST-N

root@sanganak:/etc/NetworkManager/system-connections# cat GUEST-N 
[connection]
id=GUEST-N
uuid=ed2a8866-7a0b-4cb1-96f9-0518ae77806d
type=wifi
permissions=
[wifi]
mac-address=A0:88:B4:E4:C5:64
mac-address-blacklist=
mode=infrastructure
ssid=GUEST-N
[wifi-security]
auth-alg=open
key-mgmt=wpa-psk
psk=esya@2018
[ipv4]
dns-search=
method=auto
[ipv6]
addr-gen-mode=stable-privacy
dns-search=
method=auto

You can see that the security key is listed in front of the field psk

Lets take a look at more details of another network named Tenda_3563

root@sanganak:/etc/NetworkManager/system-connections# cat Tenda_3563 
[connection]
id=Tenda_3563
uuid=6e3fcf66-1a04-4f7b-a931-90881d9ea132
type=wifi
permissions=
[wifi]
mac-address=A0:88:B4:E4:C5:64
mac-address-blacklist=
mode=infrastructure
ssid=Tenda_3563
[wifi-security]
auth-alg=open
key-mgmt=wpa-psk
psk=12345678
[ipv4]
dns-search=
method=auto
[ipv6]
addr-gen-mode=stable-privacy
dns-search=
method=auto

For the network Tenda_3563 the password listed above is 12345678

So now we know the wifi network connection details and where they are stored.