python.__init__()

Here is the small python recipient to start python development in any recent GNU/Linux environment right away:

0-) python is already installed,
1-) install ipython, very smart, python interpreter,
2-) All you need is Kate, but if you will go really deep it is worth to install eclipse and its pyDev plugin.


for help and little snippet checking ipython is more than enough, kate is a good and wise editor for development.Don't forget to tell kate fill the gaps with spaces instead of tabulators, that must be global policy for all kinds of development except for writing Makefiles.

Enabling core dump feature

Use

ulimit -c unlimited

to enable application core dump

using gdb and gdbserver

Imagine you need to use an embedded system debugger.One of the options is using gdb and gdbserver all together


To do this first you need to setup your toolchain at x86 machine.In that example out embedded system will be in ST.

Install gdbserver your embedded directory.In order to work with gdbserver we can use tcp connection to out x86 machine like that:

/root/gdbserver 192.168.1.136:1234 bin/${ST binary to debug} ${arguments to pass binary}

It's handy to get this command work in a very bottom of a shell script file after all done, environment variables, etc..

with this command we will start debugging session and awaits connection from relevant machine(x86 machine in that case)

Meantime we need to open our tcp connection to gdbserver like:


root@home$ gdb ${EXECUTABLE_FILE}
(gdb)target remote ${ip address of embedded machine}:${tcp port number of embedded machine}

after connection established, we need to enter gdb command c
(gdb) c

c stands for continue, since debugging already started that is the command we should send to gdbserver with our local gdb client.
But before starting gdb client do not forget to set corrent binary executable as well.Otherwise you will not be able to set breakpoints, and other useful stuff inside gdb.


so remote debugging starts

login to ssh without a password

Your aim

You want to use Linux and OpenSSH to automize your tasks. Therefore you need an automatic login from host A / user a to Host B / user b. You don't want to enter any passwords, because you want to call ssh from a within a shell script.
How to do it

First log in on A as user a and generate a pair of authentication keys. Do not enter a passphrase:

a@A:~> ssh-keygen -t rsa
Generating public/private rsa key pair.
Enter file in which to save the key (/home/a/.ssh/id_rsa):
Created directory '/home/a/.ssh'.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/a/.ssh/id_rsa.
Your public key has been saved in /home/a/.ssh/id_rsa.pub.
The key fingerprint is:
3e:4f:05:79:3a:9f:96:7c:3b:ad:e9:58:37:bc:37:e4 a@A

Now use ssh to create a directory ~/.ssh as user b on B. (The directory may already exist, which is fine):

a@A:~> ssh b@B mkdir -p .ssh
b@B's password:

Finally append a's new public key to b@B:.ssh/authorized_keys and enter b's password one last time:

a@A:~> cat .ssh/id_rsa.pub | ssh b@B 'cat >> .ssh/authorized_keys'
b@B's password:

From now on you can log into B as b from A as a without password:

a@A:~> ssh b@B hostname
B

A note from one of our readers: Depending on your version of SSH you might also have to do the following changes:

* Put the public key in .ssh/authorized_keys2
* Change the permissions of .ssh to 700
* Change the permissions of .ssh/authorized_keys2 to 640

Linux process state codes

Here are the different values that the s, stat and state output specifiers
(header "STAT" or "S") will display to describe the state of a process.
D Uninterruptible sleep (usually IO)
R Running or runnable (on run queue)
S Interruptible sleep (waiting for an event to complete)
T Stopped, either by a job control signal or because it is being traced.
W paging (not valid since the 2.6.xx kernel)
X dead (should never be seen)
Z Defunct ("zombie") process, terminated but not reaped by its parent.

For BSD formats and when the stat keyword is used, additional characters may
be displayed:
< high-priority (not nice to other users)
N low-priority (nice to other users)
L has pages locked into memory (for real-time and custom IO)
s is a session leader
l is multi-threaded (using CLONE_THREAD, like NPTL pthreads do)
+ is in the foreground process group

The "find"

Many *nix users are familiar with the find tool, but not all of them knows its -exec parameter.

Assume you need to find specific function or set of string-lets say printf-among lots of c source
files, what you need to do is like:

$ find . -name "*" -exec grep -i printf {} \; -print

this process will look inside of every single file on current directory-yes binary ones included!-and list files that contains printf at least one time in very nice form.This kind of commands really help.

Load balancing by using Vmware and Linux

Here I will describe load balancing guide using linux with vmware workstation 6



First step is install 1 linux os(I chosed sles 10) and clone 2 more virtual machines of that machine .We will be using 1 virtual gateway and 2 virtual network members.

Then create 2 virtual switches named vmnet8 and bridged.
connect one of the gateway interface thru bridged switch-say eth1- and other to vmnet8.
Give ip address to eth1 as you connect to internet -dhcpd e.g.- and give static ip and netmask to eth0-10.0.0.2/24 e.g.Here eth0 will be our private 10.0.0.0 network's gateway and eth1 will be our wan door.When we generate http 80-or 8080- requests it should route us to the one of the internal zone member's 80.

After installation configure gateway with:

# echo net.ipv4.ip_forward = 1 >> sysctl.conf

and reload sysctl config with :

# sysctl -p
and double-check /proc/sys/net/ipv4/ip_forward it should be 1

Second step is configure our iptables nat rules.Remember we don't have to run iptables as a service if we only want iptables running our nat rules.

Here our basic nat rules:

# iptables -t nat -F // for flushing exising iptables nat rules
# iptables -t nat -I POSTROUTING -j MASQUERADE // create an postrouting masquerade
# iptables -t nat -I PREROUTING -d 136.10.195.84 -p tcp --dport 8080 -j DNAT --to 10.0.0.3:80
// finally route all packages which come from 136.10.195.84 iface(eth1) to 10.0.0.3:80 (our member 1 apache server) via our eth0 iface on the gateway

Test step; run apache server at 10.0.0.3(@ member 1) and try to load 136.10.195.84:8080 see if it's works