NTFS Filesystem support on Linux

Ubuntu တို႕ Fedora တို႕မွာေတာ့ NTFS support က အစကတည္းကပါလာလိမ့္ရွိပါတယ္။ ဒါေတာင္တခါတစ္ေလၾက read ပဲရျပီး write မရပဲျဖစ္တက္ေသးတယ္။ က်ေနာ္က CentOS အသုံးမ်ားေတာ့ CentOS မွာက NTFS write support မပါတက္ဖူး။ Kernel recompile ရင္ေတာ့ရေပမယ့္ NTFS write ေလးရဖို႕ kernel ေတာ့ recompile မလုပ္ခ်င္ဖူး။ NTFS read/write ရေအာင္ NTFS-3G ဆိုတယ့္ FS module ရွိတယ္။ RPMforge repository မွာရွိပါတယ္။ လြယ္လြယ္ကူကူ အဲဒါေလးပဲ install လိုက္တာေကာင္းပါတယ္။

အရင္ဆုံး rpm-forge repo ကို yum repo ထဲမွာထဲ့ဖို႕လိုပါတယ္။ ဒါမွ yum နဲ႕ install လုပ္ရင္ သူ႕ဟာသူ dependency resolving လုပ္သြားမွာ။ မဟုတ္ရင္ ကိုယ့္ဟာကိုယ္ dependency ေတြ install ေနရမယ္။ CentOS လို႕ယူဆျပီးပဲ ေျပာပါမယ္။ ဒါေပမယ့္ RPM အလုပ္လုပ္တယ့္ Linux တိုင္းမွာ ရမွာပါ။

1. rpmforge rpm ေလးအရင္ download မယ္။ (wget ကေတာ့ ရွိျပီးသားလို႕ ယူဆလိုက္ပါတယ္။ မရွိရင္ေတာ့ wget အရင္ သြင္းပါ။)

#wget http://apt.sw.be/redhat/el5/en/i386/RPMS.dag/rpmforge-release-0.3.6-1.el5.rf.i386.rpm

2. GPG key import လုပ္မယ္။ မဟုတ္ရင္ RPM ကို install လုပ္လို႕မရပဲျဖစ္ေနပါလိမ့္မယ္။ 3rd party RPM ျဖစ္ေနလို႕ပါ

#rpm --import http://dag.wieers.com/rpm/packages/RPM-GPG-KEY.dag.txt

3. RPM ကိုအရင္စစ္

#rpm -K rpmforge-release-0.3.6-1.el5.rf.i386.rpm

4. RPMforge repo install လုပ္မယ္

#rpm -i rpmforge-release-0.3.6-1.el5.rf.i386.rpm

ဒီလို လုပ္လိုက္ျခင္းအားျဖင့္ ေနာက္ install လုပ္တိုင္း CentOS repo က တင္မဟုတ္ပဲ RPMforge repo ကပါ package ေတြကိုရွာပါလိမ့္မယ္။

5. RPMforge repo မွာရွိတယ့္ package ေတြရဲ့ list ကို အရင္ build လုပ္ရပါအုန္းမယ္။

#yum check-update

6. Kernel version ေလး တစ္ခ်က္ ၾကည့္ရေအာင္။ ဒါအေရးၾကီးပါတယ္။ Kernel version နဲ႕ kernel-devel version က တူဖို႕လိုပါတယ္

#uname -r

7. Kernel-devel install လုပ္မယ္။

#yum install kernel-devel

တကယ္လို႕ Kernel devel နဲ႕ Kernel နဲ႕ version မတူရင္ kernel ပါျပန္ install လုပ္ျပီး restart တစ္ခါခ်ရပါလိမ့္မယ္။ Kernel အသစ္နဲ႕ boot လုပ္ျပီးမွ က်န္တာ ဆက္လုပ္ပါ။

8. လိုအပ္တယ့္ Package ေတြကို တစ္ခါထဲ install လုပ္ရေအာင္

#yum install fuse fuse-ntfs-3g dkms dkms-fuse

9. NTFS partition ကို Linux ေပၚမွာ mount လို႕ရပါျပီ

#mount -t ntfs-3g /mount_point /windows_partition

Mount point ကေတာ့ ကိုၾကိဳက္ရာနဲ႕ အစားထိုးေပါ့။ အစကတည္းက ၾကိဳျပီး create မထားရင္လည္း အခု create လို႕ရပါတယ္။ Windows partitions ကိုမသိရင္ေတာ့ fdisk နဲ႕ၾကည့္ပါ။

#fdisk -l

ၾကလာတယ့္ table ထဲက NTFS file system နဲ႕ partition ကိုမွတ္ထား။ ဆိုၾကပါေတာ့ /dev/hda2 ဆိုရင္ အေပၚက /windows-partition ေနရာမွာ /dev/hda2 ကို အစားထိုးလိုက္ပါ။ စမ္းၾကည့္ပါ အဆင္ေျပမွာပါ။


Divinity

Server Clustering ဆိုတာ . . . (2)

Clustering မွာ ဘယ္လိုအဆင့္ေတြရွိလည္း ?
ေခါင္းစဥ္က သိပ္မကြဲပါဘူး။ ျမန္မာစာ ပညာရွိမဟုတ္ေတာ့ စကားလုံးေရြးရတာ တခါတေလ မလြယ္ဘူး။ Clustering မွာ ဘယ္လို level အလိုက္ရွိလည္းလို႕ေျပာရင္ ပိုေကာင္းမယ္။
1. Network Level Clustering
2. Service Level Clustering
3. Application Level Clustering ဆိုျပီး ေယဘူရအားျဖင့္ သုံးခုရွိပါတယ္။ Failover ပံုစံအလုပ္လုပ္မလား၊ NLB အလုပ္လုပ္မလားဆိုတာက ဘယ္လို Setup လုပ္လည္းဆိုတာေပၚမွာ မူတည္ပါတယ္။ ဘယ္လို Level clustering မွာမဆို ႏွစ္မ်ိဳးလုံး ( တစ္မ်ိဳးမဟုတ္ တစ္မ်ိဳး) setup လုပ္ဖို႕ျဖစ္ႏိုင္ပါတယ္။

Network Level Clustering ( Vs Service Level Clustering)
သူကရွင္းပါတယ္။ တကယ္လို႕ Cluster ထဲမွာ Server 5 လုံးရွိတယ္ဆိုပါေတာ့။ ဒီ Server ငါးလုံးက အခ်င္းခ်င္း Network reachability ကို စစ္ေနပါတယ္။ Engineer က configure လုပ္ထားသလို 5 seconds ဆိုလည္း 5 seconds တိုင္းမွာ၊ 5 minutes ဆိုလည္း 5 minutes တိုင္းမွာ စစ္ေနပါတယ္။ Network reachability ဆိုတာကေတာ့ က်ေနာ္တို႕ ping ၾကည့္သလိုေပါ့။ ကိုယ္သုံးတယ့္ clustering technology ေပၚမွာမူတည္ျပီး ဘယ္လိုစစ္ေနလည္းဆိုတာေတာ့ ကြာပါလိမ့္မယ္။ တကယ္လို႕ unreachable ျဖစ္သြားျပီဆိုရင္ အဲ Server down သြားျပီလို႕ ယူဆျပီး Server ကို Cluster ထဲကေနဖယ္လိုက္ပါတယ္။ ဒီ Clustering ရဲ့ အားနည္းခ်က္ကေတာ့ Server ၾကီးက မ down ဘူး၊ Server ေပၚက Service ကပဲ down ေနရင္ သူမသိပါဘူး။ သူက Network အရ ping ၾကည့္လို႕ ဒီ Server alive ရွိမရွိ စစ္တာမ်ိဳးပဲစစ္ျပီး ဆုံးျဖတ္လို႕ Network Level Clustering လို႕ေျပာတာပါ။

ဥပမာ စဥ္းစားၾကည့္ရေအာင္။ Windows Server 2003 မွာ Windows NLB Manager ဆိုတာ ပါပါတယ္။ သူက Network Level Clustering ပါ။ NLB ပံုစံ Clustering ပါ။ Server သုံးလုံးကို IIS web server run ျပီး Cluster လုပ္လိုက္ၾကတယ္ဆိုပါေတာ့ ။ User က Access လုပ္ရင္ Server သုံးလုံး တစ္လွည့္စီ respond လုပ္ေနမွာေပါ့။ တကယ္လို႕ Svr 1 က hang သြားတယ္ ဆိုပါေတာ့ ၊ ဒါမွမဟုတ္လည္း network ၾကိဳးလြတ္သြားတာပဲျဖစ္ျဖစ္၊ ဒါမ်ိဳးဆိုရင္ Svr 1 down သြားတာကို က်န္တယ့္ Sever ႏွစ္လုံးက သိပါတယ္။ လာသမွ် user ကို Svr 2 နဲ႕ 3 ကပဲ မွ်ျပီး respond လုပ္ပါလိမ့္မယ္။

ဒါေပမယ့္ တကယ္လို႕ Server 1 ၾကီးက ဘာမွမျဖစ္ဖူး ၊ IIS ကပဲ crash ျဖစ္ျပီး stop ျဖစ္သြားတယ္။ ဒီလို scenario မွာ က်န္တယ့္ Server ႏွစ္လုံးက မသိပါဘူး။ Network aspect အားျဖင့္ Server 1 က alive ရွိေနပါတယ္။ IIS Service down သြားတာ ၊ ဒီ Network Level Cluster မွာ ဒါကို မသိပါဘူး။ ဒါဆို ဘာျဖစ္မလည္း ? Cluster က Svr1 down ေနတာကို မသိတယ့္အတြက္ request 3 ခါမွာ တစ္ခါကို ထုံးစံအတိုင္း Svr1 ဆီကို ပို႕ေနပါလိမ့္မယ္။ ဒါေပမယ့္ IIS ၾကီးက down ေနေတာ့ သုံးခါမွာ တစ္ခါ error ျပေနမွာေပါ့။ Reload လုပ္လိုက္ရင္ ျပန္ေကာင္းသြားျပန္ေရာ။

ဒါဆိုဘယ္လိုလုပ္မလည္း ? Service Level ကိုပါ monitor လုပ္ႏိုင္ဖို႕လိုပါတယ္။ Windows ရဲ့ built-in ေတြမွာေတာ့ မေတြ႕မိပါဘူး။ က်ေနာ္မသိတာလည္းျဖစ္ႏိုင္ပါတယ္။ Linux မွာေတာ့ heartbeat version 2 တို႕ LDirector တို႕ေတာ့ Opensource ေတြရွိပါတယ္။ သူတို႕က Service port ကိုပဲျဖစ္ျဖစ္ Service ကိုတစ္နည္းနည္းနဲ႕ စစ္ေပးျပီး Service down ရင္လည္း Server down တယ္လို႕ သတ္မွတ္ျပီး Cluster ထဲကေန isolate လုပ္ေပးလိုက္ပါတယ္။

API ေတြနဲ႕ခ်ိတ္ဆက္ျပီး Application တစ္ခု Process တစ္ခုကို Server ေတြအမ်ားၾကီးေပၚမွာ ခြဲေဝျပီး အလုပ္လုပ္တယ့္ Application Level Clustering ကေတာ့ က်ေနာ္ ေသခ်ာမရွင္းႏိုင္တယ့္ အေၾကာင္းအရာမို႕ ေက်ာ္လိုက္ပါရေစ။

Divinity

Auto Increment ID

တစ္ခါတစ္ေလ ဒီလိုမ်ိဳးေလးမလား ၾကံဳဖူးမလားမသိဘူး။

Database Table ႏွစ္ခုရိွတယ္ဆုိပါေတာ႔။

Hibernate မသံုးတဲ႔ ရိုးရုိး ကိစၥေလးေတြမွာေျပာတာပါ။

ပထမ table ကို TableA လုိ႕ထားပါေတာ႔။

ဒုတိယ table က TableB. TableA မွာ Id က auto increment လုပ္ထားတယ္။

ရိုးသားၾကိဳးစားတဲ႔ DB Admin က normalize ေသခ်ာလုပ္ထားတဲ႔အတြက္ TableA ရဲ႕ primary key က TableB မွာ Foreign key အျဖစ္နဲ႕ ရိွပါတယ္။ ကြ်န္ေတာ္တို႕လုပ္ရမွာက Table A မွာ record တစ္ခုထည္႕လုိက္ျပီးတုိင္း TableB မွာ အဲဒီ ID ကို Foreign key အေနနဲ႕သံုးထားတဲ႔ ေနာက္ထပ္ Record တစ္ခုကို ထည္႕ရပါမယ္။

နမူနာပံုေလးကို ၾကည္႕ပါ။

Table A

ID Name NRIC

1 Zero 140222

Table B

ID ---- TableA_ID ----- Address

1 -------- 1 ---------------- Eunos Rainbow

အဲဒီလို record တစ္ေၾကာင္းစီ ထည္႕ခ်င္တာပါ။ ကြ်န္ေတာ္ေျပာခ်င္တာက Table A ကို row တစ္ခု insert လုပ္တာက ငွက္ေပ်ာသီး အခြံႏႊာတာထက္လြယ္ပါတယ္။ ေနာက္ေတာ႔ ID ကို ျပန္ရွာရတာက ပ်င္းစရာေကာင္းပါတယ္။ Select ျပန္လုပ္ရင္ရေပမယ္႔ ပ်င္းပါတယ္။ အဲဒီလို မလုိအပ္တဲ႔ code ေတြေရးမယ္႔အတူတူေတာ႔ ဘာလို႕ Developer လုပ္မွာလဲ ... ေဆာ႔ခေရတၱိေခတ္က စာကူးတဲ႔သူသြားလုပ္ေနမွာေပါ႔။ အဲဒီလုိ ငပ်င္းေတြအတြက္ တစ္ခုလုပ္လုိ႕ရတာရိွပါတယ္။ auto increment လုပ္ထားတဲ႔ ID ကို ျပန္ယူလိုက္လုိ႕ရပါတယ္။ စိတ္ခ်မ္းသာစရာေကာင္းပါတယ္။ မဟုတ္ရင္ ေနာက္တစ္ခါ သြား select လုပ္ရတဲ႔အတြက္ connection လည္းေျခေထာက္ေညာင္းမွာပဲ။ လူအေယာက္ တစ္သန္းသံုးတဲ႔ System မွာဆို အခ်ိန္အမ်ားၾကီးကုန္သြားမယ္။ ေလးငါးဆယ္ေယာက္ေလာက္သံုးဖုိ႕အတြက္ေတာ႔ System မလုိပါဘူး။ လက္နဲ႕ပဲ ေကာက္ေရးထားလုိက္ရင္ ရတာပါပဲ။ ပံုမွန္ အားျဖင္႔ Developer တစ္ေယာက္ဟာ database ကို တတ္ႏိုင္သေလာက္ အသြားအလာေလွ်ာ႔ရပါမယ္။ တစ္ခါသြားျပီး အကုန္ယူလုိ႕ရတာ ယူႏိုင္ရပါမယ္။ မယူႏုိင္ဘူးဆိုရင္ ကိုယ္႔ SQL ကို ျမွင္႔တင္ဖုိ႕လိုပါတယ္။ မဟုတ္ရင္ သြားတယ္ျပန္တယ္...ျပန္သြားတယ္ ထပ္သြားဦးမယ္ဆိုရင္ System ကေလးတယ္ ပိုေလးတယ္ ...အလုပ္မလုပ္ေတာ႔ေလာက္ေအာင္ေႏွးတယ္၊ DB sever ရဲ႕ CPU က ၁၀၀ရာခုိင္ႏႈန္း ကေနကို ျပန္က်မလာေတာ႔ဘူး။ အဲဒါမ်ဳိဳးေတြျဖစ္မယ္။ အဲဒီလိုေျပာင္ေျပာင္ေျမာက္ေျမာက္ ဒုကေပးတတ္တဲ႔ ခပ္ညံ႕ညံ႔ developer ေတြရဲ႕ code ကို boiler-plate code ေတြလုိ႕ေခၚပါတယ္။ maintain လုပ္ရတဲ႔သူကေတာ႔ ေမတၱာ အၾကိမ္ၾကိမ္ပို႕မွာ အေသအခ်ာပါပဲ။

အင္း ... အဲဒီ auto increment id ေလးျပန္ယူတာေလးေရးၾကည္႕ပါမယ္။

PreparedStatement pst = conn.prepareStatement(sQuery,Statement.RETURN_GENERATED_KEYS);

ResultSet rs = pst.getGeneratedKeys();

rs.next();

autoId = rs.getInt(1);

အဲဒီလိုေလးေရးလုိက္ရင္ autoId ကို ေနာက္တစ္ခါ ထပ္သြားမယူဘဲ သိရပါတယ္။ အသြားအလာ သက္သာသြာပါတယ္။ ေျခေထာက္မေညာင္းေတာ႔ပါဘူး။ အဲဒီ autoId ေလးကို ေကာက္ျပီး ဒုတိယ TableB မွာ insert လုပ္လုိက္ပါ။ မ်ားမ်ားစဥ္းစားျပီးနည္းနည္းပဲ အလုပ္လုပ္ပါ။ လြယ္တဲ႔နည္းေတြ ထြင္ထားျပိးသားရိွပါတယ္။ မ်ားမ်ားေလ႔လာျပီး သက္သာေအာင္ေနပါ။

သိပ္ပ်င္းတဲ႔သူေတြပဲ ထူးခြ်န္ႏိုင္တယ္။

try and error နည္းက လူပင္ပန္းသေလာက္ အက်ိဳးမရိွဘူး။ တြက္ေျခမကိုက္ဘူး။

work hard ဆိုတဲ႔စကားလံုးကို Developer ေတြမွာမသံုးပါဘူး။ Work smart လုိ႕ပဲ သံုးပါတယ္။ ပ်င္းတဲ႔သူဟာ Smart ၾကတဲ႕နည္းေတြအမ်ားၾကီးသိပါတယ္။ work hard ၾကီးေတြကို လူၾကီးေတြက ခ်ီးက်ဴးပါတယ္။ Work Smart ေတြကိုေတာ႔ ေလးစားၾကပါတယ္။ သက္သက္သာသာေလး ေလးစားခံထုိက္တဲ႔သူေတြျဖစ္ေအာင္ ၾကိဳးစားႏိုင္ၾကပါေစ။

Commit and Rollback

ဆုိၾကပါေတာ႔ ...။

လူတစ္ေယာက္က ပစၥည္းတစ္ခုကို ၀ယ္တယ္။

Discount ရတယ္။

ကံစမ္းမဲအတြက္လည္း သူ႕စာရင္းကို သြင္းတယ္။

Database View နဲ႕ Table သံုးခုလို႕ပဲ ယူဆလုိက္ပါ။

ပစၥည္း၀ယ္ေတာ႔ Purchase ဆိုတဲ႔ table မွာ တစ္ေၾကာင္း၊

Discount ရေတာ႔ Discount table မွာ တစ္ေၾကာင္း၊

Lucky Draw အတြက္ Lucky Draw table မွာတစ္ေၾကာင္း စုစုေပါင္း table သံုးခုမွာ record row သံုးေၾကာင္း insert လုပ္တယ္ဆုိပါေတာ႔။

ျဖစ္ခ်င္ေတာ႔ အင္တာနက္ၾကီးက လမ္းခုလတ္မွာေဒါင္းသြားတယ္ဆိုပါေတာ႔။Purchase table မွာ ပဲ insert လုပ္ရေသးတယ္။ Discount ေတြ၊ Lucky Draw ေတြမွာ record မေရးခင္လည္း interrupt ျဖစ္တယ္ဆုိပါေတာ႔။ ဘယ္လုိလုပ္မွာလဲ။ ဒီအတိုင္းထားလုိက္ရင္ေတာ႔၊ သူ႕အတြက္ Discount လည္းမရ၊ Lucky Draw လည္းမရတဲ႕ Customer က ဒီ Shopping Mall ၾကီးကို စိတ္အနာၾကီးနာေနေတာ႔မွာ။

လူတစ္ေယာက္တည္းျဖစ္သြားတယ္ဆိုရင္ သိပ္မသိသာဘူး။ အေယာက္ ႏွစ္ေသာင္းေလာက္ တစ္ျပိဳင္နက္၀ယ္ေနုတုန္းျဖစ္တယ္ဆိုပါေတာ႔ ....။ဟဲဟဲ ....။ ေနာက္ဘယ္ေတာ႔မွလာမ၀ယ္ေတာ႔ဘူးဆို မခက္ဘူးလား။

လူေတြလည္း သီးခ်ိန္တန္သီးပြင္႔ခ်ိန္တန္ပြင္႔ရသလို ... prepared statement ေတြလည္း commit ခ်ိန္တန္ commit ...rollback ခ်ိန္တန္ rollback ရတယ္။ အဲဒါဆို ... half way ျဖစ္ေနတဲ႔ process က rollback ျပန္လုပ္လုိက္တဲ႔အတြက္ တစ္၀က္တစ္ပ်က္ျဖစ္မေနေတာ႔ဘူး။ ေနာက္တစ္ခု ျပန္ျပီး upload လုပ္လုိက္ရံုပဲ။ ဒါကလည္း အျမဲတမ္းဂရုစိုက္ရမယ္႔အခ်က္ျဖစ္ပါတယ္။

ဘယ္ေနရာမွာပဲလုပ္ေနလုပ္ေန Java Developer တစ္ေယာက္ဟာ အျမဲတမ္း standard က်တဲ႔ procedure နဲ႕ ေရးဖုိ႕ ၾကိဳးစားေစခ်င္ပါတယ္။ ကိုယ္ေရးထားတဲ႔ codes ကို သိၾကားမင္း ဆင္းျပီး bug လုပ္ေတာင္ မရဘူးကြ ဆိုတာမ်ိဳး ေရးႏို္င္ဖုိ႕ၾကိဳးစားရပါမယ္။ အထူးသျဖင္႔ မေရးခင္ အားလံုး ကို စဥ္းစားပါ။ ေပ်ာ္ေပ်ာ္ၾကီး ခ်မေရးခ်င္ သူ႕ရဲ႕ business logic ကို flow chart ေလးျဖစ္ျဖစ္ အၾကမ္းဆြဲထားလိုက္ပါ။ စာရြက္နဲ႕ျဖစ္ျဖစ္ေပါ႔။ ဒါဆို ဘာေတြ ၾကံဳရႏိုင္လဲဆိုတာကို ပိုသိလာပါလိမ္႔မယ္။ တစ္ခု process ေတြကို scenario တစ္မ်ိဳးထဲမွာ ၾကိတ္ျပီးစဥ္းစားျပီး ေပ်ာ္မေနပါနဲ႕။ တကယ္႔ေလာကၾကီးက ကိုယ္ေတြးထားတာေလးပဲျဖစ္မယ္လုိ႕ အာမမခံထားပါဘူး။

အၾကမ္းဖ်င္းေျပာရရင္ commit အတြက္ autoCommit ကို false ေပးထားပါ။

connection တစ္ခုထဲကိုပဲ parameter အေနနဲ႕ parse လုပ္သြားျပီး table သံုးခုစလံုးကို insert လုပ္ပါ။

အားလံုးျပီးရင္ အဲဒီ connection ကို commit လုပ္ပါ။

exception ျဖစ္ရင္ rollback ျပန္လုပ္လုိက္ပါ။ အဲဒါဆိုရင္ေတာ႔ စိတ္ခ်ရသေလာက္ရိွပါျပီ။

Java Developer ေတြဟာ ငပ်င္းေတြျဖစ္ပါတယ္။

Codes တစ္ခုကို တစ္သက္လံုး ႏွစ္ခါျပန္မေရးပါဘူး။

Reusable ျဖစ္ေအာင္ေရးျပီး ဘယ္ေနရာမွာမဆို ျပန္သံုးလုိ႕ရေအာင္ ေရးရပါတယ္။

Process တစ္ခုကို Method တစ္ခုေရးျပီး ကိုယ္႔ကိုယ္ကို သက္သာေအာင္ေနပါ။

လူအမ်ားနဲ႕ေရးတဲ႔အခါ ... ကိုယ္႔ codes ေတြလူမ်ားၾကည္႕ျပီး ထုိင္မငိုပါေစနဲ႕ ...။

ႏွစ္ခါသံုးခါ ေရးရမယ္႔ method ေတြကို သပ္သပ္ခြဲထုတ္ထားလုိက္ပါ။ Eclipse မွာ ctrl+click ေခါက္ျပီး လုိက္ၾကည္႕လုိ႕ရပါတယ္။ ကိုယ္႔အတြက္ အဆင္ေျပေအာင္ေရးပါ။ နားမလည္မွာစိုးရင္ Comment ေတြကို သပ္သပ္ရပ္ရပ္ေရးပါ။ ျဖစ္ႏုိင္ရင္ comment ကို ရွည္ရွည္ေရးျပီး အၾကမ္းဖ်င္းရွင္းျပပါ။ ဒါဟာ ေနာက္လူအတြက္ သိပ္ေကာင္းပါတယ္။ ေရွ႕က ေရးသြားတဲ႔သူ ညံ႕တိုင္း လုိက္မညံ႕တဲ႔ developer ျဖစ္ႏိုင္ပါေစ။

ွ

အခုေရးထားတဲ႔ post ေလးက သီအိုရီ အေနနဲ႕ပဲေျပာထားပါတယ္။

တကယ္လည္းေရးၾကည္႕ၾကပါမယ္။ အခုလည္း hosting အတြက္ စဥ္းစားေနပါတယ္။ ရံုးက Server တစ္လံုးမွာ host လုပ္ျပီးေရးရင္လည္း illegal ျဖစ္ေနမယ္ ....။

ဘာပဲျဖစ္ျဖစ္ပါဗ်ာ ...။ ကြ်န္ေတာ္တို႕ေတြ ပိုေတာ္တဲ႔ ညီငယ္၊ညီမငယ္ေလးေတြ ဖတ္ႏိုင္ ေလ႔လာႏိုင္ဖို႕ အမ်ားၾကီးေရးျဖစ္မွာပါ။

ျမန္မာေတြဟာ well-educated ေတြဆိုတာကို ကြ်န္ေတာ္တို႕ သက္ေသျပခ်င္ပါတယ္။ ဒီလိုသက္ေသျပႏုိင္ဖို႕ ကြ်န္ေတာ္တို႕ေတြ အားလံုး ၾကိဳးစားေနၾကပါတယ္။

ကိုယ္႔အတြက္ ဘာမွမဟုတ္တာေလးေတြဟာ လုိအပ္ေနတဲ႔ တစ္ေယာက္ေယာက္အတြက္ အဆင္ေျပသြားတာမ်ိဳးျဖစ္သြားႏိုင္တယ္ဆိုကို ယံုၾကည္တဲ႔အတြက္ ဒီထက္ ပိုေကာင္းတဲ႔၊ ပိုစနစ္က်တဲ႔ သင္ခန္းစာေတြနဲ႕ ေဆြးေႏြးမႈေတြကိုလည္း ဆက္ျပီး ေရးသြားပါဦးမယ္။

Java in Linux

Java in Linux

အေသးအဖြဲေလးႏွစ္ခုေျပာမလုိ႕ပါ။

တခါတေလ ... Java Servlet အေဟာင္းေတြကို ဟိုေရႊ႕ဒီေရႊ႕လုပ္ေနရတဲ႔အခါ ...မေတာ္လို႕မ်ား Linux ေပၚကို ေရႊ႕ရတဲ႔အခါၾကရင္ ... တစ္ခါတစ္ေလ Servlet ကေန ရိုက္ထုတ္လုိက္တဲ႔ html ေတြက html လုိမေပၚဘဲ text ေတြလိုေပၚေနတတ္ပါတယ္။ မေၾကာက္သြားပါနဲ႕ ...။ ပထမဆံုးလုပ္ရမယ္႔အလုပ္က အရင္က Developer ကို တစ္ခါေလာက္ဆဲပါ။ ... ျပီးရင္ response.setContentType("html/text") လုပ္ထားသလားစစ္ပါ။ .. အသံုးမက်တဲ႔ငနဲတစ္ခ်ိဳ႕ဟာ response type ကို ထည္႕ထားေလ႔မရိွပါဘူး။ Window မွာလို ... Linux မွာ သူ႕ဘာသာသူသိမယ္ လို႕ အယူမလြဲပါနဲ႕။ Linux မွာ File extension မရိွလို႕ သူက မသိပါဘူး။ Content type ကို response လုပ္မွပဲ သူသိပါလိမ္႔မယ္။ ဒါက ၾကံဳရတတ္တဲ႔ ၾကံၾကံဖန္ဖန္တစ္ခုပါ။

ေနာက္တစ္ခုရိွပါေသးတယ္။

Java ဟာ Garbage Collection အတြက္ အမ်ားၾကီးျပဳျပင္ထားျပီးသား language ျဖစ္ပါတယ္။ ဒါေပမယ္႔ ...လက္ေတြ႕မွာ ထင္သလိုမျဖစ္တာေတြလည္း ရိွပါတယ္။ con.close() နဲ႕ပိတ္လုိက္ေပမယ္႔ Linux မွာ ပိတ္သာပိတ္တယ္ ... အဲဒီ connection ကို destroyed မလုပ္လုိက္တဲ႔အခါမ်ိဳးမွာ ... မထင္မွတ္တဲ႔ Multiple Connections Errors ေတြေတြ႕ရတတ္ပါတယ္။ ေပ်ာ္ေပ်ာ္ပါးပါးတစ္ခုလုပ္လိုက္ပါ။ con=null; ဆိုျပီး con.close(); အျပီးေတြနဲ႕ Exception handling ေတြမွာ ထည္႕ေပးလိုက္ရင္ အိုေကသြားပါတယ္။

Linux မွာ Java ကို cron နဲ႕ run တာေလးေတြလည္းေရးဖုိ႕ရိွပါေသးတယ္။

ဒီမွာေရးေနၾကတဲ႔ သူေတြက အျပင္းစားေတြမဟုတ္ဘဲ အပ်င္းစားေတြျဖစ္ေနပါတယ္ ....။ ပံုေတြနဲ႕ ေရးပါဦးမယ္ဆိုတဲ႔သူေတာင္ ပံုဆြဲရမွာပ်င္းတယ္ဆိုျပီး ငိုက္ေနတာေတြ႕ပါတယ္။

ဒီ blog ကို ပိုျပီး active ျဖစ္ေအာင္လုပ္တဲ႔အေနနဲ႕ .. Java သင္ခန္းစာေတြပါ တင္ဖုိ႕ စိတ္ကူးေနပါတယ္။

သင္တန္းတက္ဖုိ႕အခ်ိန္မရတဲ႔ ၀ါသနာရွင္ေတြအတြက္ပါ ....။ Setup လုပ္တာေတြ အားလံုး တစ္ဆင္႔ခ်င္း လုပ္ၾကည္႕ၾကတာေပါ႔ ...။ ေပ်ာ္စရာေကာင္းပါတယ္။ ၀ါသနာပါရင္ေပါ႔ေလ။

စာေရးမယ္ေျပာထားျပီး အခုအထိ မေရးေသးတဲ႔သူေတြကိုလည္း warning ထပ္ေပးပါတယ္။ ...

With Regards,

Zero Div Zero=Zero