The computing industry came of age in the 1950s, and many of the individuals who laid the groundwork for modern computing, smart electronics and the Internet are now in their 80s. Many of the leaders who passed away in 2011 were founders and chief executives who transformed their companies to take advantage of emerging technology. Several worked on the theoretical foundations in the fields of optics, mathematics and cryptography. Many knew each other as fellow members of the hobbyists group the Homebrew Computer Club.

In memory of these innovators, eWEEK honors some of the individuals who made all the things modern society takes for granted possible, such as digital computers, cellular phones and interconnected networks. While some of the pioneers are better known than others, every one of the names on this list made their mark and has inspired thousands of people with their contributions.

Read more: IT & Network Infrastructure : In Memoriam: 17 Tech Pioneers Who Died in 2011

Before starting playing the trick, you need to have Amzon EC2 API tools installed.

Then the steps are:

1. Shutdown the instance and detach the volume.
2. Build a snapshot for the detached volume and create a volume with a larger size based on the snapshot.
3. Attach the new volume to the instance and start it.
4. Login the instance and resize the root file system to fill the new EBS volume.

Commands for the last step are listed as below:

# ext3 root file system (more common):
sudo resize2fs /dev/sda1

# XFS root file system (less common):
sudo xfs_growfs /

xfs_growfs is supplied by xfsprogs, which can be installed via yum (or apt-get).

The installation is quite simple, you just need to download the source code, and run below command to compile it:

$ gcc -Wall -O3 -o vmtouch vmtouch.c

The usage examples can be seen at its homepage.

Its key features are:

• How much data of a file (or a directory) is currently in cache.
• Bring a file (or part of a file) into system memory.
• Ask the system to evict a specified file from memory, making room for other files.
• Daemonise and lock specified files into physical memory (Make sense?)

Want to have a try? Please click this link: http://hoytech.com/vmtouch/

Enjoy!

The major changes for the Lucene 3.5.0 release are:

• Lower Memory Consumption. There is a substantial reduction (3-5X) of memory needed to hold the terms index. This has been achieved by creating a more memory efficient data structure for holding terms.
• Deep Paging Support. Added IndexSearcher.searchAfter which returns results after a specified ScoreDoc. You can pass the last document on the previous page to the searchAfter method to get to the next page of results.
• SearcherManager. The org.apache.lucene.search.SearcherManager class has been added to simplify the sharing and reopening of IndexSearcher across multiple search threads. Underlying IndexReader instances are safely closed if not referenced anymore, using the IndexReader’s reference counts. The acquire method is used to retrieve an IndexSearcher and the release method is used to close the retrieved IndexSearcher.
• SearcherLifetimeManager. The org.apache.lucene.search.SearcherLifetimeManager class has been added to provide a consistent view of the index across multiple requests. It simplifies the usage of the same IndexSearcher instance between requests, which provides a better user experience when paging or drilling down/up on search results.
• IndexWriter.optimize() Deprecated. IndexWriter.optimize has been deprecated and renamed to forceMerge. This is to discourage the use of this method since it is a very costly operation and only justified if the index is static.
• IndexReader.reopen() Renamed. IndexWriter.reopen has been replaced by openIfChanged. IndexReader.openIfChanged returns null if there are no changes in the index. This method is typically less costly than opening a new IndexReader.
• NGramPhraseQuery. org.apache.lucene.search.NGramPhraseQuery is a PhraseQuery which is optimized for n-gram phrase queries. This can speed up queries 30-50% when n-gram analysis is used.

To see the full list of changes in Lucene 3.5, please visit the Lucene 3.5 Release Notes.

The major changes for the Solr 3.5.0 release are:

• Lucene 3.5.0. Fixes and enhancements from Lucene 3.5.0, most notably the substantial reduction of memory needed for holding the term index.
• Distributed Result Grouping. Support for distributed search result grouping, also called field collapsing. This feature limits the number of documents shown for each “group”, defined as the unique values in a field, and now works with distributed search.
• Language Detection. The new contrib module “langid” adds the ability to detect the language of a document before indexing, so appropriate decisions can be made. It is implemented as an UpdateRequestProcessor using Apache Tika’s LanguageIdentifier or Cybozu’s language-detection library.
• Numeric sortMissingFirst and sortMissingLast Support. Numeric types including Trie field types and dates now support sortMissingFirst and sortMissingLast.
• HunspellStemFilterFactory. Added support for Lucene’s HunspellStemmerFilter which supports stemming for 99 languages. Hunspell is originally an advanced spell checker most famously used in the OpenOffice suite and is used in Solr for stemming.
• hl.q parameter. The optional hl.q parameter has been added, and if specified, overrides the q parameter in the Highlighter (HighlightComponent).

The see the full list of changes in Solr 3.5, please visit the Solr 3.5 Release Notes.

The Citrix NetScaler implementation of GSLB is DNS-based. DNS can be thought of as the Internet’s ‘Phone Book’, telling computers where different services are located. DNS-based Global Server Load Balancers are by far the most common type of GSLB device.

GSLB directs DNS requests to the best-performing GSLB site in a distributed Internet environment. When a client sends a DNS request, the system determines the best-performing site and returns its IP to the client. In the process of ascertaining the best- performing site, the system performs these intelligent decisions:

• Directs client requests to the geographically closest GSLB site (geographic and network proximity-based traffic redirection)
• Directs client requests to surviving data centers when an outage occurs
• Directs client requests to alternate data centers, when a pre-defined traffic load limit is reached
• Directs client requests to be distributed among multiple data centers (assigns each user to the GSLB site with lowest latency)

The system performs these intelligent decisions using the Metric Exchange Protocol (MEP), GSLB policies, and GSLB methods supported by the system.

GSLB policies direct the traffic to a pre-defined target site. GSLB methods are algorithms that control how the system load-balances client requests across distributed data centers. The system provides support for creating policies for distributing or redirecting client request.

Multiple sites exchange metrics with each other using the MEP. The system uses this protocol to exchange load, network, and persistence information between GSLB sites. The system also uses this information to perform load balancing between GSLB sites.

GSLB Entity Model

A typical GSLB deployment contains the entities described in the following figure. 

To configure GSLB, you must configure a GSLB site. As shown in the figure, a GSLB site is the logical collection of GSLB vserver, GSLB service, LB vserver, service, domain, and ADNS service. It is the central entity in a GSLB deployment, and is represented by a name and an IP address.

To create a GSLB site, you must configure load balancing on the system. You must create GSLB vservers and GSLB services for each site. You must bind GSLB services to GSLB vservers. You must then create an ADNS service that provides the IP address of the best performing site to the client’s request.

A GSLB vserver is an entity that performs load balancing for the domains bound to it by returning the IP address of the best GSLB service. A GSLB service is a representation of the load balancing/content switching vserver. An LB vserver load balances incoming traffic by identifying the best server, then directs traffic to the corresponding service. It can also load-balance external DNS name servers. Services are entities that represent the servers. The domain is the domain name for which the system is the authoritative DNS server. By creating an ADNS service, the system can be configured as an authoritative DNS server.

Note: This is a modified version from the article How+GSLB+Works.

#!/usr/bin/python
#
# Check what kind of virtual machine for a running Linux. It supports (openvz/vserver/xen/uml).
# Please copy & save this script and run it as root.
#
# By Joseph Chen  2011-12-10

import sys, os
import re

def main():
    if os.getuid() != 0:
        print "It must be run as root"
        sys.exit(0)

    # Check OpenVZ/Virtuozzo
    if os.path.exists("/proc/vz"):
        if not os.path.exists("/proc/bc"):
            print "openvz container"
        else:
            print "openvz node"

    # Check V-server
    if os.path.exists("/proc/self/status"):
	s = open("/proc/self/status", "r")
	txt = s.read()
	s.close()

        reobj = re.compile(r"^(s_context|VxID):[[:blank:]]*[0-9]/")
        if reobj.match (txt):
            if os.path.exists("/proc/virtual"):
                print "vserver_host"
            else:
                print "vserver"

    # Check Xen
    if os.path.exists("/proc/xen/capabilities"):

	f = open("/proc/xen/capabilities", "r")
	text = f.read()
	f.close()

        if (len(text) > 0):
            print "xen dom0"
        else:
            print "xen domU"

    # Check User Mode Linux (UML)
    f = open("/proc/cpuinfo", "r"); t = f.read(); f.close()
    if (t.find("UML") > 0):
        print "uml"

if __name__=="__main__":
    main()

Here is a running example on a Xen dom0 node:

root@pekdev230:~ # python check-vm.py
xen dom0

Note that, the check for vserver may not work since I didn’t get an environment for testing. Sorry about that, but if you any updates, please kindly let me know.

To disable notifications

curl -d "cmd_typ=23&cmd_mod=2&host=[THE-HOST]&service=[THE-SERVICE]&btnSubmit=Commit" "http://[NAGIOS-SERVER]/nagios/cgi-bin/cmd.cgi"

To enable notifications

curl -d "cmd_typ=22&cmd_mod=2&host=[THE-HOST]&service=[THE-SERVICE]&btnSubmit=Commit" "http://[NAGIOS-SERVER]/nagios/cgi-bin/cmd.cgi"

Depending on your setup, you may also need to use the –insecure or –user options of curl.

The parameter of posted data can be assembled — look at what links are being used in your web browser.

$ curl -s --head http://www.admon.org/robots.txt
HTTP/1.1 200 OK
Date: Fri, 25 Nov 2011 05:52:11 GMT
Server: Apache/2.2.11 (Unix) PHP/5.3.8 DAV/2 SVN/1.6.4
X-Powered-By: PHP/5.3.8
X-Pingback: http://www.admon.org/xmlrpc.php
Cache-Control: max-age=303445772
Expires: Wed, 07 Jul 2021 08:21:44 GMT
Content-Type: text/plain; charset=utf-8

If the domain name is resolved to multiple IP addresses (e.g. in a CDN environment), how can we check the header on all servers one by one?
It’s not a problem, here’s a script for this task. It resolves the domain names on a list of DNS servers, and collects the resolved IP addresses, then check HTTP header on each of the server:

#!/bin/bash
#
# Check HTTP header on a list of servers.
# The servers are resolved by specified DNS servers.
#            by Joseph Chen 
# GPL v2 licensed.

# Define your DNS servers here!
DNS_LIST=(61.139.2.69 192.168.0.3)

die_msg() {
	echo $@
	exit -1
}

[ $# != 1 ] && die_msg Only accept one URL as parameter.
which  dig >/dev/null || die_msg We need the command dig to do DNS resolving.
which curl >/dev/null || die_msg We need the command curl to send request.

URL=$1
DNAME=$(echo $URL |awk -F// '{print $2}' |awk -F/ '{print $1}')
DFILE=$(echo $URL |awk -F${DNAME} '{print $2}' |awk -F? '{print $1}')

echo Start to check the requested file is $DFILE on domain $DNAME

for ((i=0; i<${#DNS_LIST[@]}; i++))
do
	echo Resolving $DNAME on DNS server ${DNS_LIST[$i]}
	dig +time=1 $DNAME @${DNS_LIST[$i]} |awk '!/^;/ && /IN\tA/{print $NF}' >/tmp/.cdn.resolved.${i}
done

echo
echo Starting to check HTTP header for $URL on these IP:
echo $(cat /tmp/.cdn.resolved.* | sort | uniq)
echo

echo Checking Last-Modified for http://${DNAME}${DFILE}
for RESOLVED_IP in $(cat /tmp/.cdn.resolved.* |sort |uniq)
do
	/bin/echo -n "Resolved IP: $RESOLVED_IP >>>> "
	curl -s --head --connect-timeout 2 --header "Host: $DNAME" http://${RESOLVED_IP}${DFILE} | grep ^Last-Modified || /bin/echo
done

rm -f /tmp/.cdn.resolved.* 2>/dev/null

A running example can be seen as below:

$ sh dump-CDN-header.sh http://adm.fwmrm.net/p/fox_live/AdManager.swf
Start to check the requested file is /p/fox_live/AdManager.swf on domain adm.fwmrm.net
Resolving adm.fwmrm.net on DNS server 61.139.2.69
Resolving adm.fwmrm.net on DNS server 192.168.0.3

Starting to check HTTP header for http://adm.fwmrm.net/p/fox_live/AdManager.swf on these IP:
124.40.41.30 124.40.41.40 125.141.136.100 125.141.136.101 125.141.136.102 125.141.136.98 193.108.88.192 205.168.236.217 205.168.236.227

Checking Last-Modified for http://adm.fwmrm.net/p/fox_live/AdManager.swf
Resolved IP: 124.40.41.30 >>>> Last-Modified: Tue, 22 Nov 2011 08:21:11 GMT
Resolved IP: 124.40.41.40 >>>> Last-Modified: Tue, 22 Nov 2011 08:21:11 GMT
Resolved IP: 125.141.136.100 >>>>
Resolved IP: 125.141.136.101 >>>>
Resolved IP: 125.141.136.102 >>>>
Resolved IP: 125.141.136.98 >>>>
Resolved IP: 193.108.88.192 >>>>
Resolved IP: 205.168.236.217 >>>> Last-Modified: Tue, 22 Nov 2011 08:21:11 GMT
Resolved IP: 205.168.236.227 >>>> Last-Modified: Tue, 22 Nov 2011 08:21:11 GMT

So, How can we limit the size of a Subversion commitment?
The solution is quite easy, use the pre-commit hook. You can find some examples after searching around. Here’s the script that I use. It reads the tmp files in db/transactions/, caculate the total size and compare it with your settings (db/tranactions only saves changesets, not original files).

If the size exceeds your limit, the commitment fails and user will be warned with details.

#!/usr/bin/env python
#
# Limit the size of SVN commits. It reads db/transactions to caculate commit size.
# Put the follwoing 3 lines in hook/pre-commit hook like this:
#
# REPOS="$1"
# TXN="$2"
# check_commit_size.py "$REPOS" "$TXN" || exit 1
#

import sys,os,popen2

# The size is not an exact value.
MAX_BYTES = 10000000

def printUsage():
    sys.stderr.write('Usage: %s "$REPOS" "$TXN" ' % sys.argv[0])

def getTransactionSize(repos, txn):
    txnRevPath = repos+'/db/transactions'+'/'+txn+'.txn'+'/rev'
    return os.stat(txnRevPath)[6]

def checkTransactionSize(repos, txn):
    size = getTransactionSize(repos, txn)
    if (size > MAX_BYTES):
        sys.stderr.write("Sorry, you are trying to commit %d bytes, which is larger than the limit of %d.\n" % (size, MAX_BYTES))
        sys.stderr.write("If you think you have a good reason to, email to Ops and ask for permission.")
        sys.exit(1)

if __name__ == "__main__":
    #Check that we got a repos and transaction with this script
    if len(sys.argv) != 3:
        printUsage()
        sys.exit(2)
    else:
        repos = sys.argv[1]
        txn = sys.argv[2]

    checkTransactionSize(repos, txn)

In addition to doing simple matching, bash regular expressions support sub-patterns for capturing parts of the match. The matches are assigned to an array variable BASH_REMATCH. The entire match is assigned to BASH_REMATCH[0], the first sub-pattern is assigned to BASH_REMATCH[1], and going forward.

Below is an example:

#!/bin/bash
# is this a number?

number=$1
if [ $# -eq 0 ] ; then
   echo Parameter is needed.
   exit
fi

[[ "$number" =~ '\<[0-9]+\>' ]] && echo 'It is a number' || echo Sorry: ${BASH_REMATCH:?"no value"}

echo "Match: $BASH_REMATCH"

The running results are:

!1064 $ sh test.sh 3123
It is a number
Match: 3123

!1065 $ sh test.sh 123sdf
test.sh: line 8: BASH_REMATCH: no value