http://pureform.wordpress.com/2009/04/08/memcache-mysql-php-session-handler/

ช่วงนี้กำลังหาโซลูชั้นเพื่อที่จะทำ centralized session ตรงกลาง เพราะเนื่องจากเริ่มมี web application หลายตัว และในบางส่วนจำเป็นต้องมีการใช้ session ร่วมกัน จึงหาการแก้ปัญหาที่ตอบโจทย์ดังกล่าวว่าจะมีการรวม session มาไว้ที่เดียวกันและมีประสิทธิภาพสูงสุดได้อย่างไร ซึ่งในโซลูชั่นสุดท้ายผมคงต้องขอไม่พูดถึง เพี่อเป็นความปลอดภัยของระบบ แต่จะกล่าวแค่เฉพาะแนวคิดเฉยๆ ครับ

การทำ centralized session หรือ เซสชั่นกลางนั้น เราสามารถทำได้ง่ายๆ โดยการหาตัวมารับหน้าที่เป็น data pool หรือที่เก็บรวบรวมข้อมูลตรงกลาง ซึ่งที่ผมจะนำไปใช้คือ MySQL สำหรับ บรรจุข้อมูลตรงกลาง ทุกเครื่องสามารถนำไปใช้งานได้ โดยเป็นข้อมูลเดียวกัน แต่เนื่องจาก MySQL จะทำการ update cache ทุกครั้งที่กำการอัพเดตข้อมูล

http://pureform.wordpress.com/2009/04/08/memcache-mysql-php-session-handler/

memcache = new Memcache;
            $this->lifeTime = intval(ini_get("session.gc_maxlifetime"));
            $this->initSessionData = null;
            $this->memcache->connect("127.0.0.1",11211);

            return true;
        }

        function open($savePath,$sessionName) {
            $sessionID = session_id();
            if ($sessionID !== "") {
                $this->initSessionData = $this->read($sessionID);
            }

            return true;
        }

        function close() {
            $this->lifeTime = null;
            $this->memcache = null;
            $this->initSessionData = null;

            return true;
        }

        function read($sessionID) {
            $data = $this->memcache->get($sessionID);
            if ($data === false) {
                # Couldn't find it in MC, ask the DB for it

                $sessionIDEscaped = mysql_real_escape_string($sessionID);
                $r = mysql_query("SELECT `sessionData` FROM `tblsessions` WHERE `sessionID`='$sessionIDEscaped'");
                if (is_resource($r) && (mysql_num_rows($r) !== 0)) {
                    $data = mysql_result($r,0,"sessionData");
                }

                # Refresh MC key: [Thanks Cal  ]
                $this->memcache->set($sessionID,$data,false,$this->lifeTime);
            }

            # The default miss for MC is (bool) false, so return it
            return $data;
        }

        function write($sessionID,$data) {
            # This is called upon script termination or when session_write_close() is called, which ever is first.
            $result = $this->memcache->set($sessionID,$data,false,$this->lifeTime);

            if ($this->initSessionData !== $data) {
                $sessionID = mysql_real_escape_string($sessionID);
                $sessionExpirationTS = ($this->lifeTime + time());
                $sessionData = mysql_real_escape_string($data);

                $r = mysql_query("REPLACE INTO `tblsessions` (`sessionID`,`sessionExpirationTS`,`sessionData`) VALUES('$sessionID',$sessionExpirationTS,'$sessionData')");
                $result = is_resource($r);
            }

            return $result;
        }

        function destroy($sessionID) {
            # Called when a user logs out...
            $this->memcache->delete($sessionID);
            $sessionID = mysql_real_escape_string($sessionID);
            mysql_query("DELETE FROM `tblsessions` WHERE `sessionID`='$sessionID'");

            return true;
        }

        function gc($maxlifetime) {
            # We need this atomic so it can clear MC keys as well...
            $r = mysql_query("SELECT `sessionID` FROM `tblsessions` WHERE `sessionExpirationTS`lifeTime));
            if (is_resource($r) && (($rows = mysql_num_rows($r)) !== 0)) {
                for ($i=0;$idestroy(mysql_result($r,$i,"sessionID"));
                }
            }

            return true;
        }
    }

    ini_set("session.gc_maxlifetime",60 * 30); # 30 minutes
    session_set_cookie_params(0,"/",".myapp.com",false,true);
    session_name("MYAPPSESSION");
    $sessionHandler = new SessionHandler();
    session_set_save_handler(array (&$sessionHandler,"open"),array (&$sessionHandler,"close"),array (&$sessionHandler,"read"),array (&$sessionHandler,"write"),array (&$sessionHandler,"destroy"),array (&$sessionHandler,"gc"));
    session_start();
?>

#container{
	width: expression(document.body.clientWidth > 1100)? "1100px" : "auto";
	/* For web browsers supporting it */
	max-width: 1100px;
}

สาเหตุ

สาเหตุก็เป็นเพราะว่า รูปผมมันเป็น http แต่เวปมันเป็น https บราวเซอร์จะไม่ยอมโหลดรูปให้ ปัญหาดังกล่าวจะเป็นเกือบทุกบราวเซอร์ โดยบางเครื่องอาจมีการถามก่อนว่าจะโหลดหรือไม่ ตามแต่ผู้ใช้งานจะเป็นผู้ตั้งไว้ แต่จุดที่สังเกตได้ง่ายๆ คือด้านมุมขวาล่าง จะมีรูปแม่กุญแจอยู่ ถ้าเป็นกรณีนี่มีการโหลด http บนเวป https จะมีรูปเครื่องหมายตกใจสีแดงปรากฎอยู่บนรูปแม่กุญแจนั้น

วิธีแก้ไข

วิธีแก้ไขที่ดีที่สุดน่าจะอยู่ที่ตัวผู้เขียนเวปเอง โดยทำการกำหนด link ต่างๆ ในหน้าเวปของเราให้เป็น https ซะ

ปัญหา

ไม่สามารถโหลดไฟล์ผ่าน SSL  โดยปัญหานี้พบกับเฉพาะ Internet Explorer 7 (IE7 โดย IE รุ่นอื่น ยังไม่ได้รับรายงานปัญหาดังกล่าว) ส่วนบราวเซอร์ตัวอื่นยังไม่พบปัญหาเช่นนี้ โดย error ที่พบ IE จะขึ้นมาที่ผู้ใช้ว่า “the file could not be written to the cache” ทำให้ไม่สามารถดาวโหลดไฟล์ได้

วิธีการแก้ไข

สามารถเลือกแก้ไขได้โดยวิธีใดวิธีหนึ่งดังนี้

สำหรับ server admin หรือ webmaster

ห้ามใส่ cache-control หรือ pragma: no-cache ลงใน header ของ http ในส่วนที่เป็น oct-stream หรือ file-download

สำหรับ client (ผมยังไม่ได้ลองครับ)

เข้าไป uncheck ตามลำดับดังนี้ IE Tools -> Internet Options -> Advanced -> Security -> Do not save encrypted
pages to disk

Getting started with Makefiles: Advanced features

1. What are macros and why should I use them?

Think of programs that shall be used at different locations: CERN, DESY, SLAC, University of Bonn, … The C/C++ programs are highly portable (at least after some effort) but the names of the programs used to compile them – as well as their arguments – may be very different. So it would be nice to once give the program name, the list of arguments, etc. and then only use symbolic names so that you can rapidly adjust to the local computing environment. Those symbolic names are called “macros”. Let’s recall Makefile5.

All object files are made using g++. On other machines that may be cxx, cpp, or something the like. So let’s define a macro for the C++ compiler:

The command line options are also different for different compilers so it’s a good idea to have a macro for them:

On some machines the command to remove files is rm (or rm -f), on others del, some use delete, some erase, and some even discard.So that’s another candidate for a macro:

Even make may not always be called make (though I know of no system where this is the case):

In our example the linker is also g++. In general that need not be the case. So we define the following two macros:

The meaning of the following two macros is obvious:

After these changes the present state of the Makefile is Makefile6:

2. What are inference rules and what are they good for?

If you have a close look at the rules to make mirror.o, input.o, output.o, and process.o you see that they are all the same:

To avoid all these lenthy entries in a Makefile there are inference rules: They describe the ’standard procedure’ of making files of type b from files of type a. In this case the rule to make an object file from a given C++ file is

or alternatively you could use

It’s easy to see what $< and $* mean but I’ll come back to that in just a moment. First I will change the rule for making the target ‘mirror’ so that it makes use of another strange-looking predefined macros:

Now let’s have a look at the meaning of $*, $<, and $@:

$* ist the current target without an extension (the base file name) with path. For example, in

the value of $* is input. $* is commonly used only in inference rules and command lines.

$@ is the current target (including extension, if any). For example, in

the value of $@ is mirror.

$< is a dependent file out-of date with the target file. For example,

Notice that $<, in an inference rule such as .cc.o, is equivalent to $*.cc (as already mentioned).

Just to remind you: Your Makefile should now look like Makefile7:

3. Continuation lines

If your project consists of a great number of files (or you need lots of options) you may wish to split lines. Another reason for splitting lines is increasing the readability of your Makefile (don’t underestimate that point!).  In Makefile7 you could change the line reading

to read

4.  Comments

You can also add comments to your Makefile like the ones in Makefile8:

5. The .SUFFIXES pseudo target

make comes with a couple of predefined rules how to make certain files. To get rid of them simply use

If you do that you have to list all suffixes that your Makefile does support. In the above case that would be

You can also use .SUFFIXES to add rules to the predefined ones (in precisely the same manner as in the example above).

6. Using environment variables

You can use environment variables in the same way as macros (besides that they are defined outside the Makefile):

Surely this is not a very useful example. Finding more useful ones is left to the reader.  Now, your Makefile should look like Makefile9: