How to Exclude Files from Git Tracking Without Using .gitignore

Git
~ tadmin

How to Exclude Files from Git Tracking Without Using .gitignore

Introduction:

In certain scenarios, you might find yourself needing to stop Git from tracking changes in specific files without adding them to `.gitignore`. This situation often arises with local configuration files, which you do not wish to share with others but still need to keep in your repository. In this post, we’ll explore how to achieve this using the `git update-index` command.

The Command:

To tell Git to ignore changes to a specific file, you can use the `–assume-unchanged` flag with `git update-index`. This command is helpful when you want to keep a file in your repository but stop tracking any changes to it. Here’s how you do it:

git update-index --assume-unchanged path/to/file

Replace `path/to/file` with the actual path to the file you want to ignore. Once you run this command, Git will no longer track changes to the file.

Reverting Back:

If, at some point, you decide you want to start tracking changes to the file again, you can reverse the process. Use the `–no-assume-unchanged` flag to tell Git to resume tracking changes:

git update-index --no-assume-unchanged path/to/file

Again, replace `path/to/file` with the relevant file path.

Conclusion:

Using `git update-index` with the `–assume-unchanged` and `–no-assume-unchanged` flags provides a flexible way to manage file tracking in Git. It’s particularly useful for files like local configurations, where you need them in your repository but don’t want their changes to be constantly tracked. Remember, this is a local operation, and these changes are specific to your repository and do not impact other collaborators.

What is the difference between print in echo in PHP?

~ tadmin

In PHP, both `print` and `echo` are used for outputting data to the screen, but there are some differences between them:

  1. Type:
    • `echo` is a language construct, not really a function, so you can use it without parentheses. It can take multiple arguments.
    • `print` is also a construct but behaves more like a function and always returns 1. It can take only one argument.
  2. Return Value:
    • `echo` does not return any value. It just outputs the arguments.
    • `print` always returns 1, so it can be used in expressions.
  3. Performance: `echo` is marginally faster than `print` because it doesn’t have a return value to check. However, this speed difference is extremely negligible and usually not a factor in choosing one over the other.
  4. Usage in Expressions:
    • Since `echo` does not return a value, it cannot be used in expressions. For example, you cannot use `echo` within a complex expression or inside a function expecting a value.
    • `print`, with its return value of 1, can be used in expressions.
  5. Argument Handling:
    • `echo` can take multiple parameters, separated by commas, to output. For example, `echo $str1, $str2;`.
    • `print` can only take one argument. To output multiple strings, you would need to concatenate them first.

In practical terms, the differences are quite minor, and choosing between `echo` and `print` usually comes down to personal preference or specific needs in certain situations (like needing a return value or handling multiple arguments). In most cases, they are interchangeable.

Merging MP3 Files Seamlessly with FFmpeg

~ tadmin

It could be useful to merge a number of mp3 files into one using the following command:

ffmpeg -i "concat:file1.mp3|file2.mp3|file3.mp3|file4.mp3|file5.mp3|file6.mp3|file7.mp3|file8.mp3" -acodec copy _all_files_combined.mp3

The command above will combine mp3 files listed in -i option into one large audio file called _all_files_combined.mp3.

Check out video tutorial version located on my Youtube channel Linux Tutorials at: https://youtu.be/1YM_G7nPQo4

Linux diff: compare two directories

~ tadmin

Comparing Directories in Linux: Essential Commands for Efficient Management

As a Linux user, you might frequently encounter the need to compare the contents of two directories. This is a common task in various scenarios, such as synchronizing files, diagnosing changes, or simply understanding the differences between two sets of data. Linux, known for its powerful command-line tools, offers several methods to accomplish this. In my professional experience, I’ve found two commands particularly useful for comparing directories.

1. Creating a Patch Format List of Changes

When you need a detailed overview of changes between two directories, the `diff` command is your go-to tool. This command can generate a comprehensive list of differences in a patch file format, which is especially useful for developers or administrators who require a clear record of changes for version control or audit purposes.

Here’s the command:

diff -Naur dir1/ dir2/ > file.patch

- `diff`: This is the command that invokes the comparison utility.
- `-Naur`: These options stand for:
  - `N`: Treat absent files as empty, which helps in creating comprehensive patches.
  - `a`: Treat all files as text, ensuring no file is overlooked due to its format.
  - `u`: Output in unified format, which is more readable and standard for patches.
  - `r`: Recursively compare any subdirectories found.
- `dir1/ dir2/`: Replace these with the paths of your directories.
- `> file.patch`: This redirects the output to a file named `file.patch`. You can name this file as you prefer.

2. Generating a Simple List of Changed Files

In situations where you only need to know which files have been altered, without the specifics of the changes, there’s a simpler command. This generates just a list of files that differ between the two directories.

Use this command:

diff -aqr dir1/ dir2/ > changed_list.txt

- `-aqr`: The options here are slightly different:
  - `a`: As before, this treats all files as text.
  - `q`: Quick mode. This reports only when files differ, not the details of the changes.
  - `r`: Recursively compares subdirectories.
- `dir1/ dir2/`: Replace with your directory paths.
- `> changed_list.txt`: This redirects the output to a file named `changed_list.txt`, which you can rename as needed.

These two commands have served me well in various professional contexts, offering both depth and simplicity as needed. Whether you’re managing web development projects, performing system administration tasks, or simply organizing your personal files, these Linux commands are essential tools in your arsenal.

Linux: create csr and key to get SSL certificate

OpenSSL
~ tadmin

Securing Your Website: A Simple Guide to Generating SSL Certificates in Linux

In today’s digital world, securing your website with an SSL certificate is not just a best practice; it’s a necessity. This process involves generating a private key and a Certificate Signing Request (CSR). For Linux users, this task can be accomplished effortlessly with a single command line input.

Here’s how you can generate your SSL certificate:

  1. Open your Linux terminal. Begin by launching your command line interface.
  2. Enter the OpenSSL command. Use the following syntax to initiate the creation of your private key and CSR: 
    openssl req -nodes -newkey rsa:2048 -keyout www.shkodenko.com.key -out www.shkodenko.com.csr
  3. Provide necessary details. You’ll be prompted to fill in various fields. These include: 
       - Country Name (2 letter code) [XX]
   - State or Province Name (full name) []
   - Locality Name (e.g., city) [Default City]
   - Organization Name (e.g., company) [Default Company Ltd]
   - Organization Unit Name (e.g., section) []
   - Common Name (e.g., your name or your server's hostname)
   - Email Address []

    These details are critical as they form the backbone of your SSL certificate, ensuring its validity and credibility.

  4. Check the generated files. After running the command, two important files will be created in the folder:
    – `www.shkodenko.com.key`: This is your private key, utilizing a robust RSA algorithm with 2048 bits encryption.
    – `www.shkodenko.com.csr`: The CSR file, essential for obtaining your SSL certificate from a Certificate Authority (CA).

By following these steps, you can secure your website with a vital layer of encryption, safeguarding both your data and your users’ trust. Remember, SSL certificates not only protect sensitive information but also boost your website’s credibility and search engine ranking.

Stay secure and happy coding!

Efficiently Displaying Configuration Files in Linux: Excluding Empty Lines and Comments

~ tadmin

Efficiently Displaying Configuration Files in Linux: Excluding Empty Lines and Comments

When working with Linux, there’s a frequent need to view the contents of configuration files, such as `/etc/my.cnf`, without the clutter of empty lines or comments. This task can be efficiently accomplished using a combination of command-line tools.

Here’s a simple yet effective command sequence:

cat /etc/my.cnf | sed '/^$/d' | grep -v "#" | more

This command pipeline works as follows:

  1. `cat /etc/my.cnf` – Displays the contents of the file `/etc/my.cnf`.
  2. `sed ‘/^$/d’` – Removes empty lines. The `sed` command searches for lines that start (`^`) and end (`$`) without any characters in between, indicating an empty line, and deletes (`d`) them.
  3. `grep -v “#”` – Excludes lines containing the ‘#’ character, commonly used for comments in config files. The `-v` flag inverts the match, showing only lines that do not contain the specified character.
  4. `more` – Paginates the output, making it easier to read through.

Customizing for Different Comment Styles

Different configuration files might use various characters for comments, such as semicolons (`;`). You can easily adapt the command to suit these differences. Simply replace the `#` in the `grep -v “#” ` section with the relevant comment character. For instance, to exclude lines with semicolons, you would use `grep -v “;”`.

This method offers a quick and customizable way to view the essential contents of configuration files, free from the usual distractions of comments and blank spaces.

Efficiently Logging Your Linux Console Activities

~ tadmin

Efficiently Logging Your Linux Console Activities

Working with the Linux console regularly demands a systematic approach to logging your activities. This practice isn’t just about keeping a record; it’s crucial for analyzing past actions and generating detailed reports. Here’s how you can achieve this with ease.

1. Understanding the `history` Command

Firstly, the Linux environment offers the `history` command, a handy tool to view your command history. However, it has a limitation: it only displays the commands, not their outputs. This is where the `script` command comes into play.

2. Harnessing the `script` Command for Comprehensive Logging

For a more robust logging solution, I prefer using:

script -a /path/to/file.log

As soon as you execute this command, it initiates a logging session, saving all console activities to the specified file. You’ll see a confirmation message:

Script started, file is /path/to/file.log

Now, every action in the console, including outputs, is being logged. This is invaluable for later review and reporting.

3. Finalizing Your Logging Session

To conclude your logging session, simply exit the console as you normally would. Upon exiting, you’ll notice a message:

Script done, file is /path/to/file.log

This message signifies that your logging is complete, and all your activities are safely stored in the specified log file.

Conclusion

With this method, you now have a comprehensive log of your console session, a resource that can prove invaluable for future reference and analysis. Happy logging! 😉

How to clear the history of a Git repository from a PHP file?

~ tadmin

In order to completely remove a PHP file from Git including its commit history, you need to follow this sequence of actions:

Make sure that you have created a working backup of the file you are going to delete and checked that you can restore from it.
Delete the file from the repository. You can do this with the following command:

git rm --cached path/to/file.php

This will save the file to a local copy of your file system and remove it from the Git repository.
Instead of path/to/file.php, specify the actual path to the PHP file you want to delete.

Commit the file deletion with the command:

git commit -m "Removed path/to/file.php from Git history"

Rewrite the Git history and remove all references to the file with the command:

git filter-branch --force --index-filter 'git rm --cached --ignore-unmatch path/to/file.php' --prune-empty --tag-name-filter cat -- --all

Instead of path/to/file.php, specify the actual path to the PHP file you want to delete.

Perform the cleanup with the command:

git for-each-ref --format="%(refname)" refs/original/ | xargs -n 1 git update-ref -d

Perform a push with the force flag with the following command:

git push origin --force --all

This command overwrites a remote Git repository with an updated history, so make sure you have a backup and don’t overwrite your important changes with it.

Please be careful when overwriting the history of a Git repository, especially if you are collaborating with other developers. Also, inform all members of your team about the upcoming changes and coordinate with them.

PHP composer show view installed libraries

Composer logo
~ tadmin

To effectively manage and view the list of all PHP libraries installed in your project using Composer, you can utilize the following command:

composer show | more

Adding the | more part to the command is particularly helpful when dealing with extensive lists. This suffix enables you to paginate the output, making it easier to read and navigate, especially when the list extends beyond the size of one screen.

For more targeted searches, especially when you need to find a specific library, you can filter the output using this command:

composer show | grep -i "packageName"

Here, | grep -i “packageName” serves as a powerful tool. It performs a case-insensitive search within your library list, allowing you to quickly locate any library fragment by name. This feature is incredibly useful for swiftly pinpointing the exact library you’re interested in, amidst a potentially large collection of installed libraries.

Dealing with Binary Files in the Console: A Quick Fix for Common Issues – using reset command

~ tadmin

Viewing binary files through the console can occasionally lead to unexpected and disruptive issues. You might have experienced situations where the console seems to ‘break’— displaying strange characters, replacing normal text with incomprehensible hieroglyphs, and even triggering unexpected sound alerts or bizarre color blends. These anomalies can render the console practically unusable, disrupting your workflow.

Fortunately, there’s a simple solution to this problem. Whenever you encounter these disruptions, just enter the command:

reset

This command effectively resets your console, clearing any irregularities and restoring its normal functionality. It’s a quick and efficient way to tackle the chaos caused by binary file interactions and ensures you can continue your work without major interruptions.

Remember, while the reset command is powerful, it’s always good practice to understand the nature of the files you’re dealing with. Use appropriate tools and commands for viewing or editing binary files to minimize these occurrences.