Think Different

Wednesday

Major GIT commands with examples

Here you will find a list with the major commands, their short descriptions and exemplary usage. For a detailed description of all the GIT commands please visit

http://www.kernel.org/pub/software/scm/git/docs/

Major GIT commands:

git config

Sets configuration values for your user name, email, gpg key, preferred diff algorithm, file formats and more.

Example: git config --global user.name "My Name"
                 git config --global user.email "user@domain.com"

cat ~/.gitconfig
[user]
    name = My Name
    email = user@domain.com

git init

Initializes a git repository – creates the initial ‘.git’ directory in a new or in an existing project.

Example: cd /home/user/my_new_git_folder/
git init

git clone

Makes a Git repository copy from a remote source. Also adds the original location as a remote so you can fetch from it again and push to it if you have permissions.

Example: git clone git@github.com:user/test.git

git add

Adds files changes in your working directory to your index.

Example: git add .

git rm

Removes files from your index and your working directory so they will not be tracked.

Example: git rm filename

git commit

Takes all of the changes written in the index, creates a new commit object pointing to it and sets the branch to point to that new commit.

Examples: git commit -m ‘committing added changes’
git commit -a -m ‘committing all changes, equals to git add and git commit’

git status

Shows you the status of files in the index versus the working directory. It will list out files that are untracked (only in your working directory), modified (tracked but not yet updated in your index), and staged (added to your index and ready for committing).

Example: git status
# On branch master
#
# Initial commit
#
# Untracked files:
# (use "git add ..." to include in what will be committed)
#
# README
nothing added to commit but untracked files present (use "git add" to track)

git branch

Lists existing branches, including remote branches if ‘-a’ is provided. Creates a new branch if a branch name is provided.

Example: git branch -a
* master
remotes/origin/master

git checkout

Checks out a different branch – switches branches by updating the index, working tree, and HEAD to reflect the chosen branch.

Example: git checkout newbranch

git merge

Merges one or more branches into your current branch and automatically creates a new commit if there are no conflicts.

Example: git merge newbranchversion

git reset

Resets your index and working directory to the state of your last commit.

Example: git reset --hard HEAD

git stash

Temporarily saves changes that you don’t want to commit immediately. You can apply the changes later.

Example: git stash
Saved working directory and index state "WIP on master: 84f241e first commit"
HEAD is now at 84f241e first commit
(To restore them type "git stash apply")

git tag

Tags a specific commit with a simple, human readable handle that never moves.

Example: git tag -a v1.0 -m 'this is version 1.0 tag'

git fetch

Fetches all the objects from the remote repository that are not present in the local one.

Example: git fetch origin

git pull

Fetches the files from the remote repository and merges it with your local one. This command is equal to the git fetch and the git merge sequence.

Example: git pull origin

git push

Pushes all the modified local objects to the remote repository and advances its branches.

Example: git push origin master

git remote

Shows all the remote versions of your repository.

Example: git remote
origin

git log

Shows a listing of commits on a branch including the corresponding details.

Example: git log
commit 84f241e8a0d768fb37ff7ad40e294b61a99a0abe
Author: User
Date: Mon May 3 09:24:05 2010 +0300

first commit

git show

Shows information about a git object.

Example: git show
commit 84f241e8a0d768fb37ff7ad40e294b61a99a0abe
Author: User
Date: Mon May 3 09:24:05 2010 +0300

first commit

diff --git a/README b/README
new file mode 100644
index 0000000..e69de29

git ls-tree

Shows a tree object, including the mode and the name of each item and the SHA-1 value of the blob or the tree that it points to.

Example: git ls-tree master^{tree}
100644 blob e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 README

git cat-file

Used to view the type of an object through the SHA-1 value.

Example: git cat-file -t e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
blob

git grep

Lets you search through your trees of content for words and phrases.

Example: git grep "www.siteground.com" -- *.php

git diff

Generates patch files or statistics of differences between paths or files in your git repository, or your index or your working directory.

Example: git diff

gitk

Graphical Tcl/Tk based interface to a local Git repository.

Example: gitk

git instaweb

Runs a web server with an interface into your local repository and automatically directs a web browser to it.

Example: git instaweb --httpd=webrick
git instaweb --stop

git archive

Creates a tar or zip file including the contents of a single tree from your repository.

Example: git archive --format=zip master^ README >file.zip

git gc

Garbage collector for your repository. Optimizes your repository. Should be run occasionally.

Example: git gc
Counting objects: 7, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (5/5), done.
Writing objects: 100% (7/7), done.
Total 7 (delta 1), reused 0 (delta 0)

git fsck

Does an integrity check of the Git file system, identifying corrupted objects.

Example: git fsck

git prune

Removes objects that are no longer pointed to by any object in any reachable branch.

Example: git prune

GIT Directory structure

A .git directory has a structure similar to the following one:

branches

A deprecated way to store shorthands that specify URL to the git fetch, git pull and git push commands is to store a file in branches/ and give the name to the command in the place of the repository argument.

COMMIT_EDITMSG

This is the last commit message. It’s not actually used by Git at all, but it is for your reference after you have made a commit.

user@user:/GIT/test# cat COMMIT_EDITMSG
first commit

config

This is the main Git configuration file. It keeps specific Git options for your project, such as your remotes, push configurations, tracking branches and more. Your configuration will be loaded first from this file, then from a ~/.gitconfig file and then from an /etc/gitconfig file, if they exist.

A exemplary content of this file is:

user@user:/GIT/test# cat config
[core]
    repositoryformatversion = 0
    filemode = false
    bare = false
    logallrefupdates = true
[remote "origin"]
    url = git@github.com:user/test.git
    fetch = +refs/heads/*:refs/remotes/origin/*

description

If you’re using gitweb or invoking git instaweb, this will show when you have viewed your repository or the list of all versioned repositories.

gitweb

A folder with the GIT web scripts. They allow you to browse the git repository using a web browser.

HEAD

This file holds a reference to the branch you are currently on. This tells Git what to use as the parent of your next commit:

user@user:/GIT/test# cat HEAD
ref: refs/heads/master

hooks/

This directory contains shell scripts that are invoked after the corresponding Git commands. For example, after you run a commit, Git will try to execute the post-commit script.

index

The Git index is used as a staging area between your working directory and your repository. You can use the index to build up a set of changes that you want to commit together. When you create a commit, what is committed is what is currently in the index, not what is in your working directory. It is a binary file containing a sorted list of path names, each with permissions and the SHA-1 of a blob object. Its content can be listed through:

user@user:/GIT/test# git ls-files --stage
100644 e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 0 README

info/

Contains additional information about the repository.

logs/

Keeps records of changes made to refs.

objects/

In this directory the data of your Git objects is stored – all the contents of the files you have ever checked in, your commits, trees and tag objects.
The files are stored by their SHA-1 values. The first two characters are for the subdirectory and the next 38 are the filename.

For example, if the SHA-1 for a blob we’ve checked in is a576fac355dd17e39fd2671b010e36299f713b4d
the path to the corresponding file is:
[GIT_DIR]/objects/a5/76fac355dd17e39fd2671b010e36299f713b4d

ORIG_HEAD

This is the previous state of HEAD.

packed-refs

The file consists of packed heads and tags. It is useful for an efficient repository access.

refs/

This directory normally contains three subfolders – heads, remotes and tags. There you will find the corresponding local branches, remote branches and tags files.

For example, if you create a production branch, the file .git/refs/heads/production will be created and will contain the SHA-1 of the latest branch commit.

courtsy: SiteGround

Monday

Getting Started with Nginx and PHP-FPM

Nginx, a HTTP and reverse proxy server, known for its blazing speed in serving static files, including grand performance in terms of serving up FastCGI pages makes for a great coupling with the upcoming PHP-FPM sapi in PHP (It is currently in the 5.3 branch and previously was a patch) offer a great solution for finally getting rid of that old sloppy mod_php in Apache. Do you have the same issue where your apache instances have started to run too large? This might be the time to start to move forward.

A little background on why I have endeavored on this path. While running Apache at several jobs and institutions it simply became clear that under heavier traffic loads having all of the ridged custom components of Apache were starting to slow things down. To the point of large instances running sometimes up to 300MB in size. Having this size just to get a simple image or PHP page was just not necessary as well as proved to be a performance bottleneck.

While the first point of departure is to utilize a faster web server to proxy the existing one, it still does not stand to the point of keeping everything to a single task. This is where the FastCGI instances of PHP started to come in very useful as well as having something to monitor the processes aka PHP-FPM.

Overview

This posting assumes that you are not operating under a shared hosting account and that you have some dedicated hardware, a virtual machine or something in the cloud. Currently I have just switched from a dedicated server at The Planet to their new cloud offering which reduced my immediate costs substantially (149 to 99 per month for essentially the same thing but even better – my disk now operates off of a SAN. To you cloud junkies, you know disk speed / IO wait time is a pain in the a**. This simply mitigates these types of issues). Which has allowed me to take some time to move over to Nginx and PHP-FPM without having to have reconfigured my existing machine to what I wanted.

Further, you must be comfortable in running everything under a single user account, this is not something for a shared hosting supplier (while you can accomplish this, it is not why I am writing this post since the security of which, is just terrible). Simply put, if you have a shared hosting account switch to a VM (cloud hosting is a VM) or a dedicated server. This may not make some of you happy to hear but there are generally a large amount of issues with shared hosting – mostly related to security. But that is another rant…. Let’s get started.

PHP-FPM

PHP-FPM is a FastCGI process manager for PHP, say goodbye to the spawn-fcgi script from Lighttpd. The PHP-FPM has additional features that can make it appealing for any crowd. To name a few:

Emergency restart in case of accidental opcode cache destruction
Enhancements to FastCGI, such as fastcgi_finish_request() – a special function to finish request & flush all data while continuing to do something time-consuming
Ability to start workers with different uid/gid/chroot/environment and different php.ini (replaces safe_mode) – Covered in the PHP-FPM workers documentation.
Adaptive process spawning

PHP-FPM has been available for quite some time, however, it is new to the PHP 5.3 branch (to date, it has not been in a packaged release from PHP). There is a bit of configuration that you will need to do with PHP in order to get up and running with PHP-FPM. If you are afraid of compiling or not using your package managers builds, then you may want to stop reading now.

PHP 5.3 + PHP-FPM Installation

Installing PHP 5.3 and including PHP-FPM is simple. I tend to statically compile many of my extensions into PHP to make maintenance more simple with multiple machines. However, this is not a necessity. To get going follow these instructions (if you already have PHP and want to maintain some of your current configuration do a php -i from the command line and grab the configure statement – excluding apache related configuration (aka apxs). I’ve removed most of my configuration from this tutorial. You may find that you need additional librarys installed (just install them through your package manager).

#!/bin/bash
wget http://us2.php.net/get/php-5.3.2.tar.gz/from/www.php.net/mirror
tar -zxf php-5.3.2.tar.gz
cd php-5.3.2
svn export http://svn.php.net/repository/php/php-src/branches/PHP_5_3/sapi/fpm sapi/fpm
rm -rf autom4te.cache
rm -f configure
./buildconf --force
./configure \
--with-layout=GNU \
--with-libdir=lib64 \
--enable-fpm \
--with-gd \
--enable-mbstring \
--enable-pcntl \
--enable-soap \
--enable-sockets \
--enable-sqlite-utf8 \
--enable-zip \
--with-zlib \
--with-curl \
--with-pcre \
--with-jpeg-dir \
--with-png-dir \
--with-zlib-dir \
--with-gettext \
--with-mcrypt \
--with-mysql \
--with-mysqli \
--with-pdo-mysql \
--with-pdo-sqlite \
--with-tidy \
--with-pear \
--with-xml \
--disable-debug
make && make install

Add Your Init Script

Download the script from: http://svn.php.net/repository/php/php-src/branches/PHP_5_3/sapi/fpm/init.d.php-fpm.in

Now that you have the script, modify it to contain the correct paths. I am not going to do this here since if you’re running your own server or virtual machine I feel you should know to do such things

Update Your Configuration

The default may run fine for you, however, it is always best to take a peak at what users are running, your port numbers and ensuring that all of your items are setup the way you want them. Look for php-fpm.conf under /etc/php-fpm.conf or /usr/local/etc/php-fpm.conf. Then update this file to your liking. Once coompleted, start it up: /etc/init.d/php-fpm start – if you have issues, ensure that your variables are correct and that the configuration lines up with the init script (aka pid file for instance).

Nginx

Installation

Most of your distributions support nginx. You can install this through your package manager, however, I prefer to have the most recent versions (and running a redhat based distro that generally requires installing from source or creating a package – there is no .spec file so I took the easy way out) therefore, I decided to install from source which is a simple task but yet I customized it a bit to exclude a few things I did not need.

Steps that you will need to follow (to some degree):

Download Nginx (we’ll use stable for now)
Extract the Package
Configure, Make and Make Install

Just as a note, I generally save my configuration in a shell script to allow for easy upgrading. You may want to do the same as it will allow you to quickly upgrade rather than attempting to figure out what you’re configure script was.

wget http://nginx.org/download/nginx-0.7.xx.tar.gz #not the real link, find current stable release on 7.x series)
tar -zxf nginx-0.7.xx.tar.gz
cd nginx-0.7.xx
./configure --with-http_ssl_module --without-mail_pop3_module --without-mail_imap_module --without-mail_smtp_module --with-http_stub_status_module
make && make install

So that was easy, or did you take the cheater way out and just install the package (which most are at 0.6)? Either way, this should still work for you.

Many tutorials (especially the one that I looked at beginning to convert to nginx simply rely on a single index.php – not that it is an issue but be wary about these tutorials since many of them exhibit issues related to security (one of which, is the first result in Google on a search for: nginx wordpress rewrite). I’ll say a little more once we get into the Site portion of the configuration.

The Main Configuration

The main configuration file is generally in /etc/nginx/nginx.conf or /usr/local/nginx/conf/nginx.conf. Here we want to setup a few of our variables to improve the server itself. There is a great guide from Slicehost on nginx defaults, you may want to get started there. Now my configuration is based quite a bit off of the Slicehost configuration as well as a few additional changes when we get more into the PHP section. For reference here is my configuration.

user  www-data;
worker_processes  4;
pid        logs/nginx.pid;
events {
    worker_connections  1024;
}
http {
    include       mime.types;
    default_type  application/octet-stream;
    server_names_hash_bucket_size 128;
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
 
    access_log  /var/log/nginx/access.log  main;
    error_log   /var/log/nginx/error.log   debug;
 
    sendfile        on;
    tcp_nopush      on;
    tcp_nodelay     off;
 
    keepalive_timeout  2;
 
    gzip  on;
    gzip_comp_level 2;
    gzip_proxied any;
    gzip_types text/plain text/css application/x-javascript text/xml application/xml application/xml+rss text/javascript;
 
    include /usr/local/nginx/sites-enabled/*;
}

One thing to note, is that due to some of my domain name sizes, I needed to increase the variable “server_names_hash_bucket_size” to 128 instead of the current default 32.

Setting up FastCGI Variables

These will be needed in order for your installation to work, as well as, setting up your environmental variables that get sent to PHP. You will notice most of these parameters.

; /etc/nginx/fastcgi_params
fastcgi_param  QUERY_STRING       $query_string;
fastcgi_param  REQUEST_METHOD     $request_method;
fastcgi_param  CONTENT_TYPE       $content_type;
fastcgi_param  CONTENT_LENGTH     $content_length;
fastcgi_param  SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param  PATH_INFO $fastcgi_script_name;
 
fastcgi_param  SCRIPT_NAME        $fastcgi_script_name;
fastcgi_param  REQUEST_URI        $request_uri;
fastcgi_param  DOCUMENT_URI       $document_uri;
fastcgi_param  DOCUMENT_ROOT      $document_root;
fastcgi_param  SERVER_PROTOCOL    $server_protocol;
 
fastcgi_param  GATEWAY_INTERFACE  CGI/1.1;
fastcgi_param  SERVER_SOFTWARE    nginx/$nginx_version;
 
fastcgi_param  REMOTE_ADDR        $remote_addr;
fastcgi_param  REMOTE_PORT        $remote_port;
fastcgi_param  SERVER_ADDR        $server_addr;
fastcgi_param  SERVER_PORT        $server_port;
fastcgi_param  SERVER_NAME        $server_name;

Now in that same file, you may want to also include some additional fastcgi configuration. These will likely need to be tuned for your environment and may take a little trial and error until you find the best fit.

fastcgi_connect_timeout 60;
fastcgi_send_timeout 180;
fastcgi_read_timeout 180;
fastcgi_buffer_size 128k;
fastcgi_buffers 4 256k;
fastcgi_busy_buffers_size 256k;
fastcgi_temp_file_write_size 256k;
fastcgi_intercept_errors on;

Setting up your First Site

Let’s configure a simple default site that just processes PHP scripts. No real hard trouble here! Create a new file in the sites-enabled directory called default.conf. We are going to have it parse our /var/www/default directory (if you do not have one, create one and add an index.php file of some sort in there). Here is a quick and simple configuration to get started:

server {
        listen 80 default;
 
        root   /var/www/default/public;
        index index.php;
 
        location ~ \.php$ {
                include /usr/local/nginx/conf/fastcgi_params;
                fastcgi_index index.php;
                if (-f $request_filename) {
                    fastcgi_pass 127.0.0.1:9000;
                }
        }
}

Note the location ~ \.php$, this tells us that for every PHP file to push it into fastcgi, now if you parse additional extensions through PHP, for the sake of everything, please add extensions to the location! Otherwise your precious PHP files can be downloaded. Yes, it is a serious thing!

What Not to Do

This configuration is evil and I actually found it on some tutorial but here it is, in it’s fully glory.

        # if the request starts with our frontcontroller, pass it on to fastcgi
        location ~ ^/index.php
        {
                fastcgi_pass 127.0.0.1:9000;
                fastcgi_param SCRIPT_FILENAME /var/www/default/pub$fastcgi_script_name;
                fastcgi_param PATH_INFO $fastcgi_script_name;
                include /usr/local/nginx/conf/fastcgi_params;
        }

See how it only pushes things to index.php? Yes, this means that no other PHP files will be parsed. WTF mate? Yes, so please do not utilize a configuration such as this unless you know the repercussions.

Non-Default Sites aka Virtual Hosts

Virtual hosts are extremely easy in Nginx, all you need to define is the server name (the same goes with subdomains). You can basically copy out the default.conf into a specific site and add in a “server_name” variable to the “sever” section followed by removing “default” from the port. You can add in aliases by simply putting a space in between the servers. Here is an example (I also cache local files for a period of 30 days since they will likely not change):

server {
        listen 80;
        server_name digitalstruct.com www.digitalstruct.com;
 
        location / {
                root   /var/www/digitalstruct.com/public;
                index index.php;
 
        }
 
        # serve static files directly
        location ~* ^.+.(jpg|jpeg|gif|css|png|js|ico|html|xml|txt)$ {
            access_log        off;
            expires           30d;
        }
 
        location ~ \.php$ {
                fastcgi_pass 127.0.0.1:9000;
                fastcgi_index index.php;
                fastcgi_param SCRIPT_FILENAME /var/www/digitalstruct.com/public$fastcgi_script_name;
                fastcgi_param PATH_INFO $fastcgi_script_name;
                include /usr/local/nginx/conf/fastcgi_params;
        }
}

That’s just about all you need for now with Nginx, if you run into issues the nginx wiki has quite a large amount of links to get you started in the right direction with rewriting those old nasty apache rewrite rules.

Conclusion

While this posting was not as detailed as I was hoping it to be, I hope that you can see some of the items that I was attempting to address, specifically the PHP portion in ensuring that you are covering yourself when it comes to ensuring that people are not downloading your configuration. Also if you are running multiple virtual hosts, it is a good idea to ensure that they are running under separate users.

courtsy:Mike Willbanks

Sunday

How to use Memcache with PHP

Memcache with PHP

Today I have new article for PHP. Last time I did post about Memcache with PHP. Today we will talking about caching in PHP again. I will show you how you can use Memcache in PHP. We will prepare useful class for working with Memcache for us and several examples. Memcache itself providing procedural and object oriented interface to memcached, highly effective caching daemon, which was especially designed to decrease database load in dynamic web applications.

I don`t have online demo for today, just because haven`t installed Memcache at our hosting. But I will include samples of using our new library in this article too (as I did for our previous APC-related post). Also, pay attention that Memcache extension not bundled with PHP by default. This extension available in PECL.

Step 1. PHP

I made this useful class for you. We will use this class to working with memory using Memcache system.

classes/memcache.caching.php

oCache = new Memcache();
            $this->bEnabled = true;
            if (! $this->oCache->connect('localhost', 11211))  { // Instead 'localhost' here can be IP
                $this->oCache = null;
                $this->bEnabled = true;
            }
        }
    }

    // get data from cache server
    function getData($sKey) {
        $vData = $this->oCache->get($sKey);
        return false === $vData ? null : $vData;
    }

    // save data to cache server
    function setData($sKey, $vData) {
        //Use MEMCACHE_COMPRESSED to store the item compressed (uses zlib).
        return $this->oCache->set($sKey, $vData, 0, $this->iTtl);
    }

    // delete data from cache server
    function delData($sKey) {
        return $this->oCache->delete($sKey);
    }
}

?>

I prepared here several necessary functions which we will use: getData, setData and delData. Now, lets check first example file:

index.php

 'table',
    'color' => 'brown',
    'size' => array(
        'x' => 200,
        'y' => 120,
        'z' => 150,
    ),
    'strength' => 10,
);

require_once('classes/memcache.caching.php');
$oCache = new CacheMemcache();

echo 'Initial data: '; // lets see what we have
print_r($aData);
echo '
';

if ($oCache->bEnabled) { // if Memcache enabled

    $oCache->setData('my_object', $aData); // saving data to cache server
    $oCache->setData('our_class_object', $oCache); // saving object of our class into cache server too

    echo 'Now we saved all in cache server, click here to check what we have in cache server';

} else {
    echo 'Seems Memcache not installed, please install it to perform tests';
}

?>

In this file you can see that I saving 2 objects in memory: some predefined array and class object. Now, lets check second example file:

index2.php

bEnabled) { // if Memcache enabled

    $aMemData = $oCache->getData('my_object'); // getting data from cache server
    $aMemData2 = $oCache->getData('our_class_object'); // getting data from cache server about our class

    echo 'Data from cache server: '; // lets see what we have from cache server
    print_r($aMemData);
    echo '
';

    echo 'Data from cache server of object of CacheMemcache class: ';
    print_r($aMemData2);
    echo '
';

    echo 'As you can see - all data read successfully, now lets remove data from cache server and check results, click here to continue';

} else {
    echo 'Seems Memcache not installed, please install it to perform tests';
}

?>

Here we only reading data from memory. And, as we see – all data is successfully read from the memory. Now, lets check last example file:

index3.php

bEnabled) { // if Memcache enabled

    $oCache->delData('my_object'); // removing data from cache server
    $oCache->delData('our_class_object'); // removing data from cache server

    $aMemData = $oCache->getData('my_object'); // lets try to get data again
    $aMemData2 = $oCache->getData('our_class_object');

    echo 'Data from cache server: '; // lets see what we have from cache server
    print_r($aMemData);
    echo '
';

    echo 'Data from cache server of object of CacheMemcache class: ';
    print_r($aMemData2);
    echo '
';

    echo 'As you can see - all data successfully removed. Great !';

} else {
    echo 'Seems Memcache not installed, please install it to perform tests';
}

?>

Step By Step Guide To Install Memcache On Linux

This post is more like a note to me, so that in future I can look up for steps involved in installing memcache on Linux servers like Centos or RHEL.

Those of you who follow me on twitter, will know that me and my friends spends hours trying to install memcache on one of our web server. Normally this is a five minute job, but unfortunately for us those tricks did not work out.

So if you have tried YUM and APT-GET and still could not install the memcache then read on, to find the alternate( read manual, without magic ) way of doing it.

When we talk about Memcache their two things that needs to be installed

Memcache Daemon know as memcached, and
Memcache client for your programing language, in this case PHP.

Installing Memcache Daemon

Note these steps has been taken fromhttp://in2.php.net/manual/en/memcache.installation.php

Steps to install Libevent(memcached dependency)

First we need to check if libevent is installed or not?
1. type whereis libevent on shell.
If you don’t find it, then we need to download and install it. Type following sequence of commands on your shell
1. wget http://www.monkey.org/~provos/libevent-1.4.8-stable.tar.gz
2. tar xfz libevent-1.4.8-stable.tar.gz
3. cd libevent-1.4.8-stable
4. ./configure
5. make
6. sudo make install
Finally we need to create a symlink to libevent
1. type sudo ln -s /usr/local/lib/libevent-1.4.so.2 /usr/lib on shell.

Now that we have installed the dependencies, we will install the memcahced.

Steps to install Memcached

Download and install, for that type following sequence of commands on your shell
1. wget http://danga.com/memcached/dist/memcached-1.2.6.tar.gz
2. tar xfz memcached-1.2.6.tar.gz
3. cd memcached-1.2.6
4. ./configure
5. make
6. sudo make install
Run Memcached as a daemon (d = daemon, m = memory, u = user, l = IP to listen to, p = port)
1. type memcached -d -m 1024 -u root -l 127.0.0.1 -p 11211 on shell

Note: versions numbers mentioned here might be outdated, so do check for updated package to download.

Now we have installed and started the Memcache daemon, it’s time to install PHP client.

Installing Memcache Extension for PHP

Some of the steps mentioned below are taken fromhttp://www.sitepoint.com/article/getting-started-with-pear/2/

Let’s determine the PHP version installed and also make sure it is in system path.
1. type php -v on you shell, it should show something like PHP 5.2.6 (cli) (built: Nov 4 2008 09:25:57)
2. type whereis php to get the path where PHP is installed in your system.
3. In your accounts home directory create/edit ‘.profile’ file and add ‘export PATH=$PATH:/usr/local/bin‘ where ‘/usr/local/bin‘ is the folder where php executable is installed.
Install PEAR, type following sequence of commands on your shell
1. wget http://pear.php.net/go-pear -O go-pear.php
2. php go-pear.php and follow the installation instructions
3. ls -l ~/.pearrc
4. edit the ‘.profile‘ (again) and add exportPATH=/home/yourname/pear/bin:$PATH
Finally Install Memcache
1. type pecl install memcache on your shell, it will install memcahce extension for PHP.
Edit php.ini to add ‘extension=memcache.so‘, to find the exact php.ini file used by your system
1. php -i | grep ‘php.ini’
Restart apache, and you are done type one of the commands below to do that
1. /etc/init.d/apache restart , or
2. service httpd restart

I hope this helps and save some time for you, I have a limited knowledge of Linux, so if some one can improve in the steps, please do so in the comments.

courtsy:thecancerus dot com

Monday

Migrating from MS Access (.mdb,.accdb) To MySQL database

This article describing how to use ESF Database Migration Toolkit to migrating data from MS-Access 2000-2007 to MySQL database and vice versa.

Introduction:

If you have not installed ESF Database Migration Toolkit, get it now .

1). In "Choose a Data Source" dialog, choose "Microsoft Access (*.mdb)" or "Microsoft Access 2007 (*.mdb;*.accdb)" if you are migrating data from Access 2007; Then press "Browse" to find the Access MDB (or ACCDB) file, if the file has a password, fill out password in "Password" field, then click "Next" to continue.

2). In "Choose a Data Destination" dialog, choose "MySQL Database", fill out the server name where MySQL locating and the server port (default is 3306), plus, you want to offer a username and password to connect it. MySQL supporting some different Storage Engines, please click here to get more information about MySQL Storage Engine. In "CharacterSet" field choose a character set like UTF-8(Notice: the chararacter set must be same as the MS Access database, otherwise, it will lost some characters when converting). Press "Refresh" button, this program will enumerate all databases locating in the MySQL server automation, you can select a database directly, or input a new database name in "Database" field, this program can create the new database in converting. Click "Next" to continue.

3). In "Select source Tables(s) & View(s)" dialog, it is listing all the tables and views in the MS Access database, you can preview source table data via "Preview" button. Selecting the tables or views that you are preparing to convert. In here, you have a chance to change the destination table name at "Destination" column. There is an "Overwrite Database" option below the list (Notice: When you check this option, the destination MySQL database will be removed, and all data will lose!). If you want to set more options for conversion, click "..." button at "Transform" column immediately.

4). In "Transform" dialog, there are some useful options for your conversion. You can only convert table structure via check "Copy Structure Only" option, or check/uncheck "Copy Indexes"/"Copy Foreign Keys" to enable/disable copy MS Access indexes/foreign keys when converting. The "Transfer auto-increment" option is most usefully for you when you converting a MS Access table with a auto-increment field (e.g.: ID), sometimes, when you append data to a MySQL table with auto-increment, perhaps you will receive a message like "Duplicable-keys...", you can uncheck this option to resolve it. Plus, you can change table/column case in "Table/Column Name" option or give a data filter (e.g.: id<100 1="1)." all="" allow="" and="" be="" can="" choose="" click="" data="" default="" done="" ecords="" empty="" etc="" f="" field="" fields="" filter="" ield="" in="" let="" list="" map="" migrate="" migrated="" name="" null="" option="" or="" p="" precision="" save="" settings.="" size="" table="" the="" this="" to="" type="" value.="" want="" when="" which="" will="" you="" your="">

5). In "Execution" Dialog, click "Submit" to starting the MS Access to MySQL conversion. When conversion is running, click "Stop" to stop the conversion.

6). To converting from MySQL to MS Access(*.mdb, *.accdb), just choose" MySQL Database" in "Choose a Data Source" page and choose "Microsoft Access (*.mdb)" or "Microsoft Access 2007 (*.accdb)" in "Choose a Destination" page , Other settings is same as above.

curtsy: easyfrom