1337ninja

[1337ninja]

Managing K8s cluster on Windows using PowerShell

Although Linux/MAC is mostly preferred to manage your Kubernetes clusters, you could also manage them on Windows as well using PowerShell.

Install kubectl

The first thing we need to do is install kubectl.

The K8s command-line tool, kubectl, allows you to run commands against K8s clusters. You can use kubectl to deploy applications, inspect and manage cluster resources, and view logs.

Once kubectl is installed, ensure it is added to Windows PATH.

Setting context, users and clusters

Once we have setup kubectl, we can manage multiple clusters.

To configure your context, users and clusters, refer the K8s docs.

Setting up PowerShell Profiles

First open PowerShell and get the path of your PowerShell Profile by typing

echo $PROFILE

By default, the profile file does not exist, even though PowerShell displays the filename on the console. It can be created using New-Item or any text editor.

For more on PowerShell profiles, refer Understanding the Six PowerShell Profiles.

Adding kubectl aliases

Copy the contents of kubectl_aliases.ps1 and add it to the PowerShell Profile from above step.

Switching contexts faster

We can switch contexts faster using the Windows version of kubectx, kubectxwin.

Download the binary kubectxwin.exe and add it to Windows PATH.

Additionally, we can also add an alias to the PowerShell Profile

Set-Alias -Name kx -Value kubectxwin

Switching namespaces faster

We can switch contexts faster using the Windows version of kubens, kubenswin.

Download the binary kubenswin.exe and add it to Windows PATH.

Additionally, we can also add an alias to PowerShell Profile

Set-Alias -Name kns -Value kubenswin

Testing it all together

Download and install Minikube

choco install minikube

Ensure Docker Desktop is running and configured with the WSL2 backend.

Start minikube

minikube start

Once it starts, we can issue the various command aliases we configured above

[1337ninja]

Making TP-Link TL-WN725N USB Wifi adapter work with Fedora 26

So you decided to get the TP-Link TL-WN725N USB wifi adapter! And when you just plugged it in your USB port on your Fedora 26 machine, you realized that there was no internet connectivity. This came as a surprise to me since Fedora always comes with the latest Linux kernel (4.12.x) and that the drivers should have been included.

The Problem

TP-Link TL-WN725N uses the RTL8188EU driver. You can find this out by firing out a terminal and giving lsusb.

[root@localhost /]# lsusb Bus 002 Device 002: ID 8087:8000 Intel Corp. Bus 002 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub Bus 001 Device 002: ID 8087:8008 Intel Corp. Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub Bus 004 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub Bus 003 Device 005: ID 0bda:8179 Realtek Semiconductor Corp. RTL8188EUS 802.11n Wireless Network Adapter Bus 003 Device 003: ID 045e:0782 Microsoft Corp. Bus 003 Device 002: ID 413c:2106 Dell Computer Corp. Dell QuietKey Keyboard Bus 003 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

The official driver listed on TP-LINK's site for TL-WN725N supports only Linux kernel versions between 2.6.18 and 3.19.3 while Fedora 26 uses 4.12.x. However, the driver is part of the staging folder of the Linux kernel and Fedora has a policy of not building and shipping them since it could be either be buggy, cause kernel panics, put undue burden on the kernel team, etc.

The Solution

Don't fret! Not all is lost. You can still compile it by yourself. First, download the source of the driver on a computer that has internet connection from here. Next, download some of the necessary rpms that the driver requires like

elfutils-libelf-devel-0.169-1.fc26.x86_64.rpm kernel-devel-4.11.8-300.fc26.x86_64.rpm kernel-headers-4.11.8-300.fc26.x86_64.rpm

Go to your target computer and install the above rpms by double clicking it or by giving

[root@localhost /]# dnf install *.rpm

Warning: Using dnf might try to connect to the online repos and error out even though you have all these rpms locally. So, installing by double clicking could be the easiest.

Once you have installed the above rpms, extract the source code of the driver that you downloaded from GitHub and do the following preferably as root

[root@localhost /]# cd rtl8188eu-master [root@localhost rtl8188eu-master]# make all

If the above command finishes without any error, then install the driver by giving

[root@localhost rtl8188eu-master]# make install

This should copy the driver rtl8188eufw.bin to the folder /lib/firmware/rtlwifi . You would see something like the following on your shell

mkdir -p /lib/firmware/rtlwifi cp rtl8188eufw.bin /lib/firmware/rtlwifi/

Finally, insert your USB dongle now in the USB port. If you had been doing this while your dongle was in the port, then just remove the dongle from the port and reconnect it.

You will now see the LED blinking :).

You are now connected to the internet.

Some Caveats

Since you have compiled the driver yourself and this is not part of the kernel yet, everytime you update the kernel, you will have to recompile the driver by repeating the above steps. If you would like to avoid this and want the driver to be part of the kernel, you can build a custom kernel. You can check about this approach here.

A lot of times, you will see connection drops or you will see that NetworkManager will show the Wifi signal as being connected, but when you hit the browser you will see that you are actually not connected to the internet. Firing up a terminal and hitting dmesg, you will see something like this

[22177.944547] R8188EU: INFO indicate disassoc [22178.459739] R8188EU: INFO indicate disassoc [22179.309493] R8188EU: INFO indicate disassoc [22181.212994] IPv6: ADDRCONF(NETDEV_UP): wlp0s20u5: link is not ready [22181.605695] IPv6:ADDRCONF(NETDEV_UP): wlp0s20u5: link is not ready [22182.933052] R8188EU:INFO indicate disassoc [22184.375390] R8188EU: INFO assoc success [22184.375458] IPv6: ADDRCONF(NETDEV_CHANGE): wlp0s20u5: link becomes ready [22633.346511] R8188EU: INFO indicate disassoc [22635.043480] R8188EU: INFO assoc success

The line R8188EU: INFO indicate disassoc is because that NetworkManager uses the modern nl80211 driver while the Realtek chipset uses the deprecated wext driver. A hack solution would be to turn off Wi-Fi in NetworkManager and turn it back on. This seems to solve the connectivity problem. The only issue is you might have to do this quite frequently.

If you're looking for a foolproof solution, then you can disable NetworkManager and install wicd.

If you want to hack even further, i.e not use any network managers at all, then you can use wpa_supplicant. For more details on this, check this blog here.

Happy Hacking :)

Further reading and reference

http://www.thelinuxrain.com/articles/getting-realtek-8188eu-wireless-adapters-to-work-in-linux-and-possibly-other-wireless-realtek-chipsets

https://linuxmender.wordpress.com/2017/07/05/fedora-26-rtl8188eu-the-hard-way/

http://www.tp-link.com/us/download/TL-WN725N.html#Driver

https://fedoraproject.org/wiki/KernelStagingPolicy

https://github.com/lwfinger/rtl8188eu/

[1337ninja]

How to send a patch to a mailing list using git imap-send with Gmail Two Factor Authentication (2FA) enabled

While most open source projects accept contributions through a pull request, a lot of projects accept contributions through patches mailed them to their mailing list. In this post, I'll show how to send a patch using git’s format-patch.

First commit the changes. Lets call the commit message “fix use after free”, a common bug in C, where one attempts to use a pointer that was just freed.

git comit -m “fix use after free”

Next, create an mbox compatible patch using git format-patch. If no name is specified for the patch, git creates one based on the commit message.

git format-patch master 0001-fix-use-after-free.patch

You can verify the contents of the patch to ensure your changes

cat 0001-fix-use-after-free.patch From 2583f0a9a9cf1369ef4b7e29623776aaa8795db0 Mon Sep 17 00:00:00 2001 From: Gmail User <[email protected]> Date: Sun, 9 Jul 2017 10:05:47 +0530 Subject: [PATCH] fix use after free --- grub-core/normal/crypto.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/grub-core/normal/crypto.c b/grub-core/normal/crypto.c index 2bfd67c..e6d345f 100644 --- a/grub-core/normal/crypto.c +++ b/grub-core/normal/crypto.c @@ -147,8 +147,8 @@ read_crypto_list (const char *prefix) if (! cur->modname) { grub_errno = GRUB_ERR_NONE; - grub_free (cur); grub_free (cur->name); + grub_free (cur); continue; } cur->next = crypto_specs; -- 2.9.4

Generate app-specific password for Gmail (if 2FA is enabled)

If you have 2FA enabled for Gmail, then you would need to generate an app-specific password instead of your usual password. Click here to generate an app specific password to use with git. For detailed steps on how to generate the password, see Google's help page.

Mailing the patch

Next, we need to configure the imap section for git, so that we can send our patch to Gmail's Drafts folder. Create a gitconfig file in your home folder, ~/.gitconfig and enter the following in the imap section. The password would be the 16 digit key generated in the previous step.

[imap] folder = "[Gmail]/Drafts" host = imaps://imap.gmail.com user = [email protected] pass = abcdefghijklmnop

Normally I wouldn't recommend storing your passwords on plaintext file. If you're paranoid like me, then remove the pass line from the .gitconfig file. This would prompt you to enter the password every time you want to send a patch. This could become particularly painstaking when you want to push a lot of commits and need to enter the password every time. In that case, you can consider using gitcredentials which has options of storing it securely.

Finally, when you're all set, mail the patch using imap-send

cat *.patch | git imap-send

That's it! Login to Gmail and check your Drafts folder. Your email would be sitting there. Make any changes if needed, add the mailing list in the "To" field and hit send. You have now successfully sent a patch and help made the opensource world better. Happy hacking!

[1337ninja]

How to configure Atom to not mess with your git diff

Gone are the days of vim and emacs. Enter the new trio of text editors, Atom, VS Code and Sublime. In this post, I’ll elucidate on how to configure Atom so that it plays easy with git and spares you the headache of dealing with unnecessary changes that you did not make.

Atom is a rad text editor from Github. However the hackable text editor of the 21st century has a serious knack to mess with your files when you edit them and click Save. All that you might have done would have been an innocent one line change, but when you just see your git diff, you would have seen a ton of changes reported by git with lots of blank lines and spaces inserted. 

I spent a lot of time online trying to figure out about this misbehavior and finally narrowed down the culprit. It was caused by the package whitespace. The simplest solution is to Disable the package by clicking Edit->Preferences->Packages and searching for whitespace as shown below

Doing this would disable all the extra lines that were inserted by Atom. Now that one half of the problem is solved there’s still a possibility that the line you changed wouldn’t exactly respect the tabs and spaces of the previous lines which brings us to the second half. The Tab Type option under Edit->Preferences->Editor is by default set as auto which inserts a Soft Tab (space). If you want a Hard Tab you can change it from the Tab Type option. 

If your source code has a mix of Tabs and Spaces, then the only option that you have got is to copy paste the Invisibles (tabs and spaces). By default this would be hidden and you would have to choose the Show Invisibles from the Editor settings. 

After all this hacking, you’d finally see the change that you want to. Hey, Atom lived up to its reputation of being the hackable text editor of the 21st century!

[1337ninja]

Recursions, the unusual way!

Like the famous quote goes, 

“To iterate is human; to recurse divine!”

I just thought it would be fun to recurse in a little unusual way. So I’ll be using the classic factorial problem as an example for this post. Please assume the following typedef for all the code samples 

typedef unsigned long long ull;

The Old School way!

We all know how a factorial is recursively calculated. 

ull factorial_recursion_classic(int N) { return (N < 2 ? 1: N * factorial_recursion_classic(N-1)); }

The above version is quite often the usual way to calculate the factorial. Now lets dive into the unusual ways :).

Template Metaprogramming (TMP)

Using the beauty of templates, metaprogramming was discovered! And using the beauty of metaprogramming, recursions were uncovered! The great thing about using TMP is that the values are computed at compile time We will see 2 different methods using TMP to do recursions.

1. Using Function Templates

The factorial function template is defined as follows. Since the values would be computed at compile time, we can use constexpr

template <int N> constexpr ull factorial_function_template() { return N * factorial_function_template<N-1>(); }

The above would recursively calculate the factorial. But we need a terminating condition for the recursion. So we'll specify the terminating condition using template specialization.

template <> constexpr ull factorial_function_template<1>() { return 1; }

2. Using Classes

We can use classes and TMP to perform recursions. The recursive definition is as follows:

template <ull N> struct factorial_class { static const ull val = factorial_class<N-1>::val * N; };

Like in the previous method, we'll terminate the recursion using template specialization.

template <> struct factorial_class<1> { static const ull val = 1; };

Lambdas

We can also use lambdas to implement recursions indirectly.

3. Using std::function

We can use std::function in conjunction with lambdas to implement recursion.

std::function<ull(int)> factorial_lambda_std_func; factorial_lambda_std_func = [&factorial_lambda_std_func](int n) -> ull { return (n < 2 ? 1 : n * factorial_lambda_std_func(n-1)); };

4. Using function pointers

The above approach using std::function is a little inefficient. Based on this answer on Stackoverflow, we can use stateless lambdas which can access static variables and can be converted to function pointers

static ull (*factorial_lambda_func_ptr)(int) = [](int n) -> ull { return (n < 2 ? 1 : n * factorial_lambda_func_ptr(n-1)); };

You can refer the full code here on Github.

[1337ninja]

Unit Testing writing to a file in C++

Quite often while dealing with writing to files, we face the challenge of unit testing it. It’s not common to encounter a code like this:

void WriteToFile(ofstream& ofs, string sData) { ofs << sData; }

And while invoking this code, we could see something like the following:

string sData = "test"; ofstream ofs; ofs.open ("test.txt", std::ofstream::out | std::ofstream::app); WriteToFile(ofs, sData);

The problem with the above code is that while unit testing it, it would actually create a file and write data into it. Since a proper unit test, would require avoiding system interaction with filesystems and databases, we would have to mock it.

The Solution

We could actually exploit the beauty of C++ inbuilt classes here. If you notice the stream classes, both ofstream and ostringstream derive from ostream. So we could actually change our WriteToFile method to accept an ostream instead of an ofstream.

void WriteToFile(ostream& os, string sData) { os << sData; }

This refactoring now makes our code unit test friendly without breaking original functionality. We can use ostream in our production code while we can use ostringstream in our test code.

You can refer the full code here on Github.

[1337ninja]

Adding Syntax Highlighting to Tumblr

We developers have this obsession to write code everywhere. And seeing code as a simple plain text is very disturbing to our eyes. Turns out adding Syntax highlighting to Tumblr is pretty easy. I will be using Google Prettify here to add syntax highlighting.

First, go to your Account icon (right corner) and choose Edit Appearance

Next in the page that comes choose Edit Theme.

From the left pane, choose Edit HTML.

Inside your <head>, add the following javascript,

<script src="https://cdn.rawgit.com/google/code-prettify/master/loader/run_prettify.js?skin=sunburst"></script>

In your <body> tag, add the following, onload="prettyPrint()"

Click Update Preview and Save and you're done!

Integrating Prettify in Tumblr posts

Now that we have added the Prettify JS, we can integrate in our post easily.

Go to the HTML editor by clicking on the settings icon of your blog post

Next, nest your code between <pre class="prettyprint"> and</pre> tag.Please use a text editor and change all > to > and all < to <

#include<iostream> int main() { int i = 5; std::cout<<"hello world"; }

The dashboard view would now display a code block. Don’t fret! Select Preview on Blog option to view your Syntax highlighted changes from the dropdown next to Save draft.

Adding line numbers

If you would like to add line numbers to your code simply add the css class linenums in the <pre> tag. This would add line numbers after every 5 lines. If you want to add line numbers to every line then, add the following css code ( You can add this by giving Edit Theme then selecting Advanced Options and then adding in the Custom CSS option )

li.L0, li.L1, li.L2, li.L3, li.L5, li.L6, li.L7, li.L8 { list-style-type: decimal !important }

Further reading and reference

Google Prettify

http://snippets-of-code.tumblr.com/post/6027484416/adding-syntax-highlighting-into-tumblr

[1337ninja]

C++ Musings

Demystifying Lvalue references

Hello everyone, so here’s an interesting piece of code. The following program would print 10 when it's run.

#include <iostream> using std::cout; int globalvar = 20; int& foo() { return globalvar; } int main() { foo() = 10; cout << globalvar; return 0; }

The interesting line in the above program would be at line 13,

foo() = 10;

If you notice closely such initialization is possible because the method foo returns a reference to an integer. If in line 6, if the function was defined as

int foo()

then we would get an error thrown by gcc at line 13

error: lvalue required as left operand of assignment

So without further ado, lets dig in to see what's happening under the hood. We'll use gdb to debug and disassemble the program.

(gdb) break main Breakpoint 1, main () at ref.cpp:13 13 foo() = 10; (gdb) disassemble Dump of assembler code for function main(): 0x080485ae <+0>: push %ebp 0x080485af <+1>: mov %esp,%ebp 0x080485b1 <+3>: and $0xfffffff0,%esp 0x080485b4 <+6>: sub $0x10,%esp => 0x080485b7 <+9>: call 0x80485a4 <foo()> 0x080485bc <+14>: movl $0xa,(%eax) 0x080485c2 <+20>: mov 0x8049988,%eax 0x080485c7 <+25>: mov %eax,0x4(%esp) 0x080485cb <+29>: movl $0x80499a0,(%esp) 0x080485d2 <+36>: call 0x8048474 <_ZNSolsEi@plt> 0x080485d7 <+41>: mov $0x0,%eax 0x080485dc <+46>: leave 0x080485dd <+47>: ret End of assembler dump.

In the above disassembly, we see that the current execution is at instruction 0x080485b7, where we call the method foo.

0x080485b7 <+9>: call 0x80485a4 <foo()>

We step into the method foo which is located at address 0x80485a4 and disassemble again.

(gdb) step foo () at ref.cpp:8 8 return globalvar; (gdb) disassemble Dump of assembler code for function foo(): 0x080485a4 <+0>: push %ebp 0x080485a5 <+1>: mov %esp,%ebp => 0x080485a7 <+3>: mov $0x8049988,%eax 0x080485ac <+8>: pop %ebp 0x080485ad <+9>: ret End of assembler dump.

We see that inside the function, the value at address 0x8049988 is moved to the eax register.

0x080485a7 <+3>: mov $0x8049988,%eax

The value at that address 0x8049988 is the value of the global variable globalvar . To verify, we just introspect the value at that address.

(gdb) x/d 0x8049988 0x8049988 <globalvar>: 20 (gdb) next 9 } (gdb) info registers eax eax 0x8049988 134519176

Once the function returns, the next step is where the magic of reference unfolds. Particularly,

0x080485bc <+14>: movl $0xa,(%eax)

This is how the assignment is made possible. In the above instruction, we move-immediate the integer 10 into the address location pointed by eax, which is nothing but the address of globalvar . To think of this instruction in C terms, this statement is similar to

*eax = 10; //eax = &globalvar

We can verify that the value of globalvar has now been modified as 10.

(gdb) x/d 0x8049988 0x8049988 <globalvar>: 10

The instructions from 0x080485c2, corresponds to passing this value to cout to print on the console.

C++ Real World Example

So now we have demystified Lvalue reference can you think of a place where such a scenario would be used in C++? We come of this subtle piece of code almost daily but fail to realize it. Okay, it's simple. We come across this type of scenario when we overload the [] operator for STL map or vector. For instance, say we are having a vector of doubles, then the operator [] method would roughly look like this,

double& operator[](int i) { return elem[i]; }

The above return by reference allows assignment such as follows possible

vector v(2); v[0] = 9.8;

References and Further Reading

http://eli.thegreenplace.net/2011/12/15/understanding-lvalues-and-rvalues-in-c-and-c

https://isocpp.org/wiki/faq/references#assigning-refs

http://accu.org/index.php/journals/227

[1337ninja]

Bash Musings!

Kill a process by giving it’s name (the whimsical way)

If you’d like to kill a process by giving it’s name using the kill command alone, it’s easy to do in a single line in bash as follows

kill $(ps -A | grep <program> | awk -F\  ‘{print $1}’)

Say for instance, your process name is codeblocks, then to kill it, simply type  kill $(ps -A | grep codeblocks | awk -F\  ‘{print $1}’)

Explanation

Let’s understand the above command step by step. Lets dissect the command step by step.

We are going to kill the program codeblocks. The kill command will only kill a process if we give it’s pid. But we would like to kill a process by giving it’s program name. So we use a combination of ps, grep and awk.

ps -A : This gives the list of all pids that are currently running on the system. The output of ps -A looks like this:

 We see that the pid of codeblocks is 7392. Extracting this pid would be our goal here, since we want to kill the process by giving the process name. 

grep codeblocks : We pipe the output of the above ps command to grep to select the line containing the program to be killed. In this case, it is codeblocks and you can see it highlighted in the image above.

awk -F\  ‘{print $1}’: This is the final part. Here we retrive the pid (7392) to supply for the kill command. What we are doing here is using the space character as delimiter. ie the ‘\ ‘ and choosing the first part alone. Note there are two spaces, one is the usual syntax of awk and the other is where we are delimiting the string based on a space, hence we use ‘\ ’. Going back to the image again, we would see that the output of ps -A  has a space after the pid. In this case 7392 ?. So in the above command print $1 would give 7392. This is then supplied to kill which kills the program. 

P.S: There are other simpler ways to achieve this using other programs like killall, pkill as described here. Given the beauty of Linux to solve a problem in multiple ways, I’ve used my own whimsical way to solve this. Happy hacking :)