2014/12/31

REPLAY 重播 - Ken Grimwood

REPLAY 是作者 Ken Grimwood 在 1987年 發表的作品,商周出版的中文版,初版是在 2009年,我是最近才買的初版二刷,等於是我在看了一本 27年前就發表的經典作品。

時間悖論

首先得再複習一次時間悖論,由 時間悖論 wiki 的說明,時間悖論通常又稱為祖父悖論,如果有一個人經過時間旅行,回到過去,殺害了自己的祖父,那麼就不會有父親,也不會有他,既然這個人不存在,怎麼能回去殺害自己的祖父呢?

因此搭配著時光旅行,通常會使用「平行宇宙」的概念,來解決時光旅行所產生的時間悖論問題,換句話說,就是當有一個人回到了過去,這時候就會因為多了他這個人,而產生了一個新的平行宇宙,這樣解釋,就解決了時間悖論的問題。

我們可以看一下這個影片的說明,會有更清楚的概念:




影片中提到的重點,就是已經發生的事情,是無法改變的,當一個人回到了過去,就是到了一個平行宇宙,殺掉了爺爺,也只是在那個平行宇宙中發生的事情,而且在那個平行宇宙中,這個人是從來都沒有出生的。

REPLAY

REPLAY情節的高明之處,就是不使用平行宇宙這個老掉牙的解決方式,男女主角傑夫跟潘密拉,都在1888年10月18日死亡,而死亡後,卻突然發現自己又在一個地方醒過來了,原來他們都回到了過去,但是在同一個身體裡面。

男女主角都有著小時候的容貌,但卻有著前幾次生命的所有記憶,換句話說,因為是同一個形體,身為人這樣的物理存在,在三度空間中,是完全沒有改變的,我們還是無法在四度空間中自由旅行的,而只是在第四度空間變換了刻度。

男女主角因應著前世的記憶,以預測的賭博方式賺錢,但他們必須永遠在這樣的時間循環中,不斷地重來,他們曾經墮落過,也曾經運用這些記憶,解救過很多人。男女主角在無數次的重逢與相愛中不斷地循環。

當他們發現重生的時間離死亡時間越來越近的時候,任何事情都無所謂了,因為他們都終將死亡,不斷地死亡。就在死亡跟重生時間一直重疊的狀況下,時間往前走了,走到了下一秒鐘。

實際上,這個時空的所有事物都沒有改變,改變的是這兩位重生者大量的互動與記憶。

超時空攔截 Predestination

同樣的時空旅行,超時空攔截這部電影,選擇的方式,是把時空悖論的理念玩到極致,主角 Jane 是個棄嬰,女性外表,卻有著男性的體能,因此被選擇進入了時間特派員,就像是個時空警察。

故事一開始的爆炸後,有一大段時間,是一個男生在 Bar 裡面跟酒保對話,看起來越看越奇怪,這跟爆炸案根本沒有關係。這個男生 John 講述了他由女變男的一段驚人的過去。

更特別的是,Jane 邂逅了一個特別的男性,還跟這個人生下了一個女嬰,在 John 跟著酒保這個時間特工回到過去後,才發現那個特別的男生人就是 John自己,自己跟自己生了一個小女孩。

這小女孩在育嬰室就被盜走,後來慢慢的才知道,原來這酒保也是 John,他在解除爆炸案的過程中毀容並重建了容貌,這個時間特工為了完成最後一個任務,回到了紐約,發現爆炸案也是另一個自己引發的。

跳脫平行宇宙的劇情

Replay 跟 Predestination 同樣都是時空旅行的題材,但以完全相反的兩種方式闡述劇情,不過他們同樣都跳脫了平行宇宙的解法,兩個故事,都只使用了一個時間軸。

如果可以的話,建議大家把兩個故事都找來看看,對比看看,會覺得非常有趣,而且佩服這兩個作品的創作者。

References

超時空攔截/前目的地Predestination——時空悖論的極端演繹
超時空攔截 wiki

REPLAY 讀後感
我讀 肯恩.格林伍德的《REPLAY重播》

2014/12/29

話務量 電話流量單位 erlang

erlang 是話務量的單位,簡單地說,是表示每小時連續的總通話長度數量,我們可根據此話務量的數值,作為設計電話通訊網路流量的規模參考數值。

由來

在 1946 年,CCITT(International Telegraph and Telephone Consultative Committee) 也就是現在的 ITU-T (International Telecommunication Union-Telecommunication Standardization Sector) 將電話話務流量命名為 erlang,命名來自丹麥數學家及統計學家 Agner Krarup Erlang

A.K. Erlang 是在 1878 年出生於丹麥,是電信流量理論的專家,在 1909年發表了第一個著作: The Theory of Probabilities and Telephone Conversations。1929年過世後,到了1940年代,erlang 這個電信流量計算公式被大家廣為接受。

erlang 計算範例

如果一條電話線被佔用 1 小時,話務量就是 1 erlang。
如果一條電話線被佔用 0.5 小時,話務量是 0.5 erlang。

假設有一組使用者,在一個小時內產生了30通電話,平均每一通電話持續了 5 分鐘,那麼 erlang 值可以按照以下步驟計算:

  1. 一小時內的電話流量總時間 = 通話數量 (BHCA) X 平均每一通電話的通話時間 (Holding Time, hrs)
  2. 通話數量為 30
  3. 平均每一通電話的通話時間為 5/60 (hrs)
  4. 30 * 5 / 60 = 2.5

因此在這個範例中,erlang 值就是 2.5。

Traffic Models

當取得 erlang 數值後,就可以套用到話務模型中,用以計算電話系統必須要提供幾條外撥線路給這一群使用者使用。

目前有三種話務模型,其中以 Erlang B 最為常被使用

  1. Erlang B
  2. Extended Erlang B
  3. Erlang C

Erlang B 有三個參數

  1. BHT: Busy Hour Traffic (in Erlangs)
    這就是剛剛計算出來的 erlang 數值,要以此電話系統最忙碌的那一個小時內的資料,計算出此 erlang 數值。
  2. Blocking
    這是因為外撥線路不足,發生無法外撥電話的錯誤通話數,如果是0.01,就表示每 100 通電話,會發生 1 次無法外撥電話的錯誤。
  3. Lines
    就是我們需要知道的計算結果,在這一組電話系統中,要提供幾條外撥線路的數量。

Erlang B 線上計算頁面 可計算出結果,如果是以 BHT = 2.5,Blocking = 0.01 去計算,可得到 Lines 結果為 7 。

Trunking 中繼

Trunking 中繼是兩點間的一條傳輸通道,通常兩點都是電話交換中心。Trunking 在以前是利用實體線路將兩點連接起來,隨著科技發展,中繼的概念不僅應用於無線通信中,基於網際網路的電信交換機的trunk也可以稱為一種中繼。

Erlang Traffic Model 中計算得到的結果 Lines,就是用在連接兩個電話交換中心之間的 trunking 能夠支援的同時通話線路數量。

參考資料

  1. wiki: Erlang (unit)
  2. What is erlang
  3. 話務量
  4. 什麼是Erlang B公式,什麼是Erlang C公式?

2014/12/28

平面國 - Edwin Abbott Abbott

平面國是一本以二維與三維空間為立論概念的小說,故事的主角是個正方形,生活在一個二度空間的平面上。如果你認為,這是本在討論生硬的數學理論的科普故事,那就大錯特錯了,小說的內容不僅涵蓋了幾何數學,還有哲學的對話討論,階級社會制度的殘酷。這是一本非常值得去閱讀與討論的書,也該列入青少年必讀的書單中。

沒有高度的平面幾何

在一個平面上,是只有長度跟寬度的,即使我們用筆,在紙上畫出任何的形狀,在物理的領域中,畫出的線段,全部都有著高度,而且會因為畫筆的材質,而產生不同的效果,例如:使用炭筆,高度就會比用原子筆畫出來的高一些,還有可能會發生線段上的高度忽高忽矮的狀況。

然而在數學的領域中,平面上的幾何圖形,全部都是沒有高度的,或許更精確的說法是,這高度非常地矮,矮到非常接近 0 ,但又不等於 0 ,因為等於 0 就等同於沒有這條線了。

身處在三維空間之中,我們只知道在紙上對數學題目作答,但有沒有想過,我們隨手在紙上畫的三角形、正方形或其他形狀,把自己想像成其中一份子的時候,在這個平面上生活,會是什麼光景。

作者在書本的第一個部份,就是透過一個正方形的視角,來告訴讀者,生活在平面上會是什麼樣的感覺,看到的、聽到的、觸摸到的、聞到的,究竟會是什麼。

該怎麼想像呢?現在先讓自己在紙上畫出一個正三角形,就像是下圖最上面那個三角形,接下來把自己的眼睛從紙張的正上方慢慢地往下移,移動的時候,還是持續看著自己畫的三角形,我們會發現這三角形已經慢慢地縮小,直到眼睛跟桌面同高的時候,我們只能看到一條直線。



生活在平面上,為了要識別男女、階級,必須發展一些感官的方法。包含了視覺、聽覺、觸覺這些方式,而這都必須讓自己設身處地想像自己生活在平面上,才能得到的解決方式,藉由介紹平面國的過程,讀者也慢慢地學會換個角度去觀察事物,換成正方形這個主角的角度去觀察平面國。

由遺傳主導的階級制度

平面國的女性,天生就是直線,而且女性永遠不會改變形狀,至於男性則是從最低階的等腰三角形,往上一層是正三角形、然後是正方形、正五邊形等等,形狀並不是直接遺傳下來的,卻是間接慢慢地由正三角形經過數個世代的演化,變成四邊形,男性的形狀會隨著時間而增加邊的數量。

當邊的數量增加到非常多的時候,就會越來越接近圓形,平面國的圓形因為數量稀少,具有非常崇高的地位,就像是原住民的祭師一樣唯一的存在。

平面國國民天生就會有這樣邊數增加的過程,社會就因為這種生理的現象,自然而然地就形成階級,即使在故事的中間,曾經發生過色彩革命,爭權的結果,最後也再次因為圓形主教卑劣的手段,將叛亂份子一網打盡,全部都處死了。

當社會地位會因為世襲而繼承時,這社會就會充滿了不公平,因為每一個新生兒一出生,除了繼承了父母的面貌與體型,更繼承了父母的社會地位,而且自動往上增加一個層次。

當階級有了世襲的因素,這社會就產生了不公平,國民們也只能被動接受,對這樣的生活無可奈何,也只能慢慢地期待,自己的後代會漸漸地增加邊的數量,晉升高級知識分子的行列。

男尊女卑的社會制度

平面國的女性是直線,完完全全的直線,連形狀都沒有,根本稱不上是在平面上存在的圖形,女性天生的不同,也沒有任何進化的可能性,造就了純粹男尊女卑的社會制度。女性是不能接受教育的,單純只有育養後代的功能。

又因為直線的正面就跟所有男性的形狀,看起來完全一樣,當女性轉了90度,就會變成一個點,而尖銳的直線,是可以把其他形狀刺死的,因此這個社會就得搭配許多規定,例如女性必須隨時發出聲音,必須永遠以直線這個方向面對家人。

為了平面國社會的永續發展,女性也只好在不得已的情況下,要接受這樣的社會規範與支配。人類的性別雖然天生會有一些基本的差別,但幸好不像是平面國一樣,差異那麼大,我們的社會,絕對能接受各種性別平權的制度。

將自己的手腳伸入平面,伸入直線

球體把自己伸入到平面之中,這對他來說是非常簡單的事情,一進去之後,會一直讓正方形覺得自己就是圓形主教。而當他從二度空間,觀察線段國之後,可以再進一步進入到第 0 維空間,線段國國王的生活限制更多了,沒辦法跟自己的同胞交換位置,只能用大叫的方式跟國民溝通。

比上不足、比下有餘,正方形覺得線段國王非常愚蠢,而球體也覺得當個正方形狠愚蠢,正方形無法想像的第三維度,同時球體也無法想像的第四維度。這可不是簡單地把高度拉長就好了。

啟發正方形的球體,也無法想像什麼是四度甚至更高維度的空間

身在三維空間的球體,輕易地就能把正方形提出平面國,在 24 小時內,就讓正方形了解了第三維度,也就是高度實際存在的世界。

直線的人民,無法了解第二維度,平面國的人民無法了解第三維度,都得等到自己被拉出生活的維度之後,才恍然大悟,發現了新的維度存在的事實。

但球體也沒想到,他也會被正方形挑戰,因為正方形領悟到了,或許除了第 0、1、2、3 這些維度,還有著第四維度,這是身處於立體空間的人民無法理解的存在。甚至還有第五維度,第六維度等等。

被挑戰的球體,似乎也從來沒有想過第四維度的存在,唯一的方式,也只能嚇斥正方形,別再講那些危言聳聽的話。

這件事告訴我們,我們不會永遠正確,也永遠要放大心胸,站在真理的一方,只要是合理的推論,就會有存在的可能性。

身為多維空間的先知,只能老死在監獄中

這個問題有因果關係的先決條件,我們現在是以承認有多維空間的方式,來討論這個事情的話,那麼正方形身為多維空間的先知,只能老死在監獄中,的確是一件非常可惜的事情,這就像是我們以我們現在的知識,去探討哥白尼那個時代,哥白尼提出了地球繞著太陽旋轉這個理論,跟當時的教會對立,我們會認為哥白尼是個先知,而先知的下場是抑鬱而終。

但如果轉換到當時那個年代,一直以來接受的教育都是地球為中心的理論,再怎麼去想,也沒辦法一下子就接受哥白尼的理論。

事實上,我們所該做到的,是接受與了解所有的意見與可能性,再透過對話與討論,去釐清每一個人的論點與意見,而不是像老師打手心一樣的制約方法,在其他人提出論點時,就拿出棒子先敲一下,然後就忽略他。

一個有效的溝通循環,要從理解與對話開始,如果沒有辦法引起對話與共鳴,就只會是單方向的宣導與強迫,這種方式,是沒有辦法讓所有人有發自內心的接受某些制度與作法。

結論

這本書的內容並不算太多,雖然未來有無限的可能,未來或許也沒那麼大機會,能再看到類似題材的作品,能將數學完完全全融合到一本小說的作品。

這是非常值得去閱讀與討論的小說,建議大家去看看。

2014/12/22

如何使用 snmp4j 處理 trap

以下以 snmp4j 套件提供處理 trap 的範例。

multithread trap receiver

trap receiver 必須在本機建立一個 UDP Port 162 的 server,一直等待 client 端發送 UDP trap,在處理這樣的 server時,multithread 是必要的。

程式範例

import java.io.IOException;
import java.net.UnknownHostException;
import java.util.Iterator;
import java.util.Vector;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.snmp4j.CommandResponder;
import org.snmp4j.CommandResponderEvent;
import org.snmp4j.MessageDispatcherImpl;
import org.snmp4j.Snmp;
import org.snmp4j.TransportMapping;
import org.snmp4j.mp.MPv1;
import org.snmp4j.mp.MPv2c;
import org.snmp4j.mp.MPv3;
import org.snmp4j.security.AuthMD5;
import org.snmp4j.security.PrivDES;
import org.snmp4j.security.SecurityModels;
import org.snmp4j.security.SecurityProtocols;
import org.snmp4j.security.USM;
import org.snmp4j.security.UsmUser;
import org.snmp4j.smi.Address;
import org.snmp4j.smi.GenericAddress;
import org.snmp4j.smi.OctetString;
import org.snmp4j.smi.TcpAddress;
import org.snmp4j.smi.UdpAddress;
import org.snmp4j.smi.VariableBinding;
import org.snmp4j.transport.DefaultTcpTransportMapping;
import org.snmp4j.transport.DefaultUdpTransportMapping;
import org.snmp4j.util.MultiThreadedMessageDispatcher;
import org.snmp4j.util.ThreadPool;

public class SNMPTrapReceiver implements CommandResponder {
    public static Logger logger = LoggerFactory
            .getLogger(SNMPTrapReceiver.class.getName());

    private MultiThreadedMessageDispatcher dispatcher;
    private Snmp snmp = null;
    private Address listenAddress;
    private ThreadPool threadPool;
    private int n = 0;
    private long start = -1;

    public SNMPTrapReceiver() {
    }

    public static void main(String[] args) {
        new SNMPTrapReceiver().run();
    }

    private void run() {
        try {
            init();
            snmp.addCommandResponder(this);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    private void init() throws UnknownHostException, IOException {
        threadPool = ThreadPool.create("Trap", 10);
        dispatcher = new MultiThreadedMessageDispatcher(threadPool,
                new MessageDispatcherImpl());
        listenAddress = GenericAddress.parse(System.getProperty(
                "snmp4j.listenAddress", "udp:0.0.0.0/162"));
        TransportMapping<?> transport;
        if (listenAddress instanceof UdpAddress) {
            transport = new DefaultUdpTransportMapping(
                    (UdpAddress) listenAddress);
        } else {
            transport = new DefaultTcpTransportMapping(
                    (TcpAddress) listenAddress);
        }
        USM usm = new USM(SecurityProtocols.getInstance(), new OctetString(
                MPv3.createLocalEngineID()), 0);
        usm.setEngineDiscoveryEnabled(true);

        snmp = new Snmp(dispatcher, transport);
        snmp.getMessageDispatcher().addMessageProcessingModel(new MPv1());
        snmp.getMessageDispatcher().addMessageProcessingModel(new MPv2c());
        snmp.getMessageDispatcher().addMessageProcessingModel(new MPv3(usm));
        SecurityModels.getInstance().addSecurityModel(usm);
        snmp.getUSM().addUser(
                new OctetString("MD5DES"),
                new UsmUser(new OctetString("MD5DES"), AuthMD5.ID,
                        new OctetString("UserName"), PrivDES.ID,
                        new OctetString("PasswordUser")));
        snmp.getUSM().addUser(new OctetString("MD5DES"),
                new UsmUser(new OctetString("MD5DES"), null, null, null, null));

        snmp.listen();
    }

    public void processPdu(CommandResponderEvent event) {
        if (start < 0) {
            start = System.currentTimeMillis() - 1;
        }
        n++;
        if ((n % 100 == 1)) {
            logger.info("Processed "
                    + (n / (double) (System.currentTimeMillis() - start))
                    * 1000 + "/s, total=" + n);
        }

        StringBuffer msg = new StringBuffer();
        msg.append(event.toString());
        Vector<? extends VariableBinding> varBinds = event.getPDU()
                .getVariableBindings();
        if (varBinds != null && !varBinds.isEmpty()) {
            Iterator<? extends VariableBinding> varIter = varBinds.iterator();
            while (varIter.hasNext()) {
                VariableBinding var = varIter.next();
                msg.append(var.toString()).append(";");
            }
        }
        logger.info("Message Received: " + msg.toString());
    }
}

這是發送 trap 的範例,有區分 snmp v1, v2c, v3 三種協定。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.snmp4j.CommandResponder;
import org.snmp4j.CommandResponderEvent;
import org.snmp4j.CommunityTarget;
import org.snmp4j.PDU;
import org.snmp4j.ScopedPDU;
import org.snmp4j.Snmp;
import org.snmp4j.TransportMapping;
import org.snmp4j.UserTarget;
import org.snmp4j.mp.MPv3;
import org.snmp4j.mp.SnmpConstants;
import org.snmp4j.security.SecurityLevel;
import org.snmp4j.security.SecurityModels;
import org.snmp4j.security.SecurityProtocols;
import org.snmp4j.security.USM;
import org.snmp4j.security.UsmUser;
import org.snmp4j.smi.Address;
import org.snmp4j.smi.GenericAddress;
import org.snmp4j.smi.IpAddress;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.OctetString;
import org.snmp4j.smi.UdpAddress;
import org.snmp4j.smi.VariableBinding;
import org.snmp4j.transport.DefaultUdpTransportMapping;
import org.snmp4j.util.DefaultPDUFactory;

public class SNMPTrapGeneratorClient {
    public static Logger logger = LoggerFactory
            .getLogger(SNMPTrapGeneratorClient.class.getName());

    private static final String community = "public";
    private static final String trapOid = ".1.3.6.1.2.1.1.6";
    private static final String ipAddress = "127.0.0.1";
    private static final int port = 162;

    public static void main(String args[]) {
        sendSnmpV1V2Trap(SnmpConstants.version1);
        sendSnmpV1V2Trap(SnmpConstants.version2c);
        sendSnmpV3Trap();
    }

    /**
     * This methods sends the V1/V2 trap
     * 
     * @param version
     */
    private static void sendSnmpV1V2Trap(int version) {
        // send trap
        sendV1orV2Trap(version, community, ipAddress, port);
    }

    private static PDU createPdu(int snmpVersion) {
        PDU pdu = DefaultPDUFactory.createPDU(snmpVersion);
        if (snmpVersion == SnmpConstants.version1) {
            pdu.setType(PDU.V1TRAP);
        } else {
            pdu.setType(PDU.TRAP);
        }
        pdu.add(new VariableBinding(SnmpConstants.sysUpTime));
        pdu.add(new VariableBinding(SnmpConstants.snmpTrapOID, new OID(trapOid)));
        pdu.add(new VariableBinding(SnmpConstants.snmpTrapAddress,
                new IpAddress(ipAddress)));
        pdu.add(new VariableBinding(new OID(trapOid), new OctetString("Major")));
        return pdu;
    }

    private static void sendV1orV2Trap(int snmpVersion, String community,
            String ipAddress, int port) {
        try {
            // create v1/v2 PDU
            PDU snmpPDU = createPdu(snmpVersion);

            // Create Transport Mapping
            TransportMapping<?> transport = new DefaultUdpTransportMapping();
            transport.listen();

            // Create Target
            CommunityTarget comtarget = new CommunityTarget();
            comtarget.setCommunity(new OctetString(community));
            comtarget.setVersion(snmpVersion);
            comtarget.setAddress(new UdpAddress(ipAddress + "/" + port));
            comtarget.setRetries(2);
            comtarget.setTimeout(5000);

            // Send the PDU
            Snmp snmp = new Snmp(transport);
            snmp.send(snmpPDU, comtarget);
            logger.info("Sent Trap to (IP:Port)=> " + ipAddress + ":" + port);
            snmp.close();
        } catch (Exception e) {
            logger.error("Error: ", e);
        }
    }

    /**
     * Sends the v3 trap
     */
    private static void sendSnmpV3Trap() {
        try {
            Address targetAddress = GenericAddress.parse("udp:" + ipAddress
                    + "/" + port);
            TransportMapping<?> transport = new DefaultUdpTransportMapping();
            Snmp snmp = new Snmp(transport);
            USM usm = new USM(SecurityProtocols.getInstance(), new OctetString(
                    MPv3.createLocalEngineID()), 0);
            SecurityModels.getInstance().addSecurityModel(usm);
            transport.listen();

            snmp.getUSM().addUser(
                    new OctetString("MD5DES"),
                    new UsmUser(new OctetString("MD5DES"), null, null, null,
                            null));

            // Create Target
            UserTarget target = new UserTarget();
            target.setAddress(targetAddress);
            target.setRetries(1);
            target.setTimeout(11500);
            target.setVersion(SnmpConstants.version3);
            target.setSecurityLevel(SecurityLevel.NOAUTH_NOPRIV);
            target.setSecurityName(new OctetString("MD5DES"));

            // Create PDU for V3
            ScopedPDU pdu = new ScopedPDU();
            pdu.setType(ScopedPDU.NOTIFICATION);
            pdu.add(new VariableBinding(SnmpConstants.sysUpTime));
            pdu.add(new VariableBinding(SnmpConstants.snmpTrapOID,
                    SnmpConstants.linkDown));
            pdu.add(new VariableBinding(new OID(trapOid), new OctetString(
                    "Major")));

            // Send the PDU
            snmp.send(pdu, target);
            logger.info("Sending Trap to (IP:Port)=> " + ipAddress + ":"
                    + port);
            snmp.addCommandResponder(new CommandResponder() {
                public void processPdu(CommandResponderEvent arg0) {
                    logger.info(arg0);
                }
            });
            snmp.close();
        } catch (Exception e) {
            logger.error("Error: ", e);
        }
    }
}

執行結果

trap 發送端,很單純地就直接把 trap 送出去

2014-12-08 10:43:51,195 [main] INFO  SNMPTrapGeneratorClient 91
 Sent Trap to (IP:Port)=> 127.0.0.1:162
2014-12-08 10:43:51,204 [main] INFO  SNMPTrapGeneratorClient 91
 Sent Trap to (IP:Port)=> 127.0.0.1:162
2014-12-08 10:43:51,224 [main] INFO  SNMPTrapGeneratorClient 137
 Sending Trap to (IP:Port)=> 127.0.0.1:162

trap 接收端

2014-12-08 10:43:51,279 [Trap.1] INFO  SNMPTrapReceiver 102
 Processed 1000.0/s, total=2
2014-12-08 10:43:51,279 [Trap.0] INFO  SNMPTrapReceiver 118
 Message Received: CommandResponderEvent[securityModel=1, securityLevel=1, maxSizeResponsePDU=65535, pduHandle=PduHandle[0], stateReference=StateReference[msgID=0,pduHandle=PduHandle[0],securityEngineID=null,securityModel=null,securityName=public,securityLevel=1,contextEngineID=null,contextName=null,retryMsgIDs=null], pdu=V1TRAP[reqestID=0,timestamp=0:00:00.00,enterprise=0.0,genericTrap=0,specificTrap=0, VBS[1.3.6.1.2.1.1.3.0 = Null; 1.3.6.1.6.3.1.1.4.1.0 = 1.3.6.1.2.1.1.6; 1.3.6.1.6.3.18.1.3.0 = 127.0.0.1; 1.3.6.1.2.1.1.6 = Major]], messageProcessingModel=0, securityName=public, processed=false, peerAddress=127.0.0.1/51136, transportMapping=org.snmp4j.transport.DefaultUdpTransportMapping@13fdb89, tmStateReference=null]1.3.6.1.2.1.1.3.0 = Null;1.3.6.1.6.3.1.1.4.1.0 = 1.3.6.1.2.1.1.6;1.3.6.1.6.3.18.1.3.0 = 127.0.0.1;1.3.6.1.2.1.1.6 = Major;
2014-12-08 10:43:51,286 [Trap.1] INFO  SNMPTrapReceiver 118
 Message Received: CommandResponderEvent[securityModel=2, securityLevel=1, maxSizeResponsePDU=65535, pduHandle=PduHandle[1338161657], stateReference=StateReference[msgID=0,pduHandle=PduHandle[1338161657],securityEngineID=null,securityModel=null,securityName=public,securityLevel=1,contextEngineID=null,contextName=null,retryMsgIDs=null], pdu=TRAP[requestID=1338161657, errorStatus=Success(0), errorIndex=0, VBS[1.3.6.1.2.1.1.3.0 = Null; 1.3.6.1.6.3.1.1.4.1.0 = 1.3.6.1.2.1.1.6; 1.3.6.1.6.3.18.1.3.0 = 127.0.0.1; 1.3.6.1.2.1.1.6 = Major]], messageProcessingModel=1, securityName=public, processed=false, peerAddress=127.0.0.1/51138, transportMapping=org.snmp4j.transport.DefaultUdpTransportMapping@13fdb89, tmStateReference=null]1.3.6.1.2.1.1.3.0 = Null;1.3.6.1.6.3.1.1.4.1.0 = 1.3.6.1.2.1.1.6;1.3.6.1.6.3.18.1.3.0 = 127.0.0.1;1.3.6.1.2.1.1.6 = Major;
2014-12-08 10:43:51,312 [Trap.2] INFO SNMPTrapReceiver 118
 Message Received: CommandResponderEvent[securityModel=3, securityLevel=1, maxSizeResponsePDU=65428, pduHandle=PduHandle[1828414888], stateReference=null, pdu=TRAP[{contextEngineID=80:00:13:70:01:c0:a8:01:39:e2:ca:22:3e, contextName=}, requestID=1828414888, errorStatus=0, errorIndex=0, VBS[1.3.6.1.2.1.1.3.0 = Null; 1.3.6.1.6.3.1.1.4.1.0 = 1.3.6.1.6.3.1.1.5.3; 1.3.6.1.2.1.1.6 = Major]], messageProcessingModel=3, securityName=MD5DES, processed=false, peerAddress=127.0.0.1/51139, transportMapping=org.snmp4j.transport.DefaultUdpTransportMapping@13fdb89, tmStateReference=null]1.3.6.1.2.1.1.3.0 = Null;1.3.6.1.6.3.1.1.4.1.0 = 1.3.6.1.6.3.1.1.5.3;1.3.6.1.2.1.1.6 = Major;

Reference

Trap Receiver

2014/12/15

如何使用 snmp4j 進行查詢

SNMP 的原理跟概念 分為 Agent 與 Client 兩端需要處理,如果不是提供機器與服務的,就不需要做 Agent 這個 Server,一般最基本的 SNMP 程式設計是撰寫 SNMP Client,Client 又有兩個部份 (1) SNMP GET, Walk (2) Trap Receiver,以下以 snmp4j 套件提供第一個部份 SNMP GET, Walk 的範例。

SNMP GET

給予 server ip,這邊刻意將程式區分為 connect, snmpget, close 三個部份,因為 UDP 本身是 connection less 的一種網路連線,未來在使用時,只要連結起來,應該就能持續發送 SNMP GET,並取得結果。

snmpGet 有兩種 method,第一種就單純地只接受一個 oid 參數,第二種,是接受一個 oid List,可一次查詢多個 oid 的結果。

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.snmp4j.CommunityTarget;
import org.snmp4j.PDU;
import org.snmp4j.Snmp;
import org.snmp4j.event.ResponseEvent;
import org.snmp4j.mp.SnmpConstants;
import org.snmp4j.smi.GenericAddress;
import org.snmp4j.smi.Integer32;
import org.snmp4j.smi.Null;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.OctetString;
import org.snmp4j.smi.Variable;
import org.snmp4j.smi.VariableBinding;
import org.snmp4j.transport.DefaultUdpTransportMapping;

public class SnmpGet {
    public static Logger logger = LoggerFactory.getLogger(SnmpGet.class
            .getName());

    private static int version = SnmpConstants.version1;
    private static String protocol = "udp";

    private static CommunityTarget target = null;
    private static DefaultUdpTransportMapping udpTransportMapping = null;
    private static Snmp snmp = null;

    public static void main(String[] args) {

        String ip = "192.168.1.8";
        String community = "public";
        int port = 161;

        Variable var = null;
        SnmpGet tester = new SnmpGet();
        // tester.snmpGet(ip, port, community, oidval);
        try {
            tester.connect(ip, port, community);
            // System Uptime(系統運行時間) 的 oid, 最前面的 . 可以忽略不寫
            String oid = ".1.3.6.1.2.1.1.3.0";
            var = tester.snmpGet(oid);
            logger.info(oid + " = " + var);

            Thread.sleep(3 * 1000);
            logger.info("");
            oid = ".1.3.6.1.2.1.1.1.0";
            var = tester.snmpGet(oid);
            logger.info(oid + " = " + var);

            Thread.sleep(3 * 1000);
            logger.info("");
            logger.info("SNMP GetList");
            List<String> oidList = new ArrayList<String>();
            oidList.add(".1.3.6.1.2.1.1.1.0");
            oidList.add(".1.3.6.1.2.1.1.3.0");
            oidList.add(".1.3.6.1.2.1.1.5.0");

            List<VariableBinding> vblist = tester.snmpGet(oidList);
            for (VariableBinding vb : vblist) {
                logger.info("oid:" + vb.getOid() + ", var=" + vb.getVariable());
            }
        } catch (Exception e) {
            logger.error("Error:", e);
        } finally {
            tester.close();
        }
    }

    public void connect(String ip, int port, String community) throws Exception {
        String address = protocol + ":" + ip + "/" + port;
        // CommunityTarget target = SnmpUtil.createCommunityTarget(address,
        // community, version, 2 * 1000L, 3);

        target = new CommunityTarget();
        target.setCommunity(new OctetString(community));
        target.setAddress(GenericAddress.parse(address));
        target.setVersion(version);
        target.setTimeout(2 * 1000L); // milliseconds
        target.setRetries(3); // retry 3次

        try {
            udpTransportMapping = new DefaultUdpTransportMapping();
            // 這裡一定要呼叫 listen, 才能收到結果
            udpTransportMapping.listen();
            snmp = new Snmp(udpTransportMapping);

        } catch (Exception e) {
            logger.error("Error", e);
            throw e;
        }
    }

    public void close() {
        if (snmp != null) {
            try {
                snmp.close();
            } catch (IOException ex1) {
                snmp = null;
            }
        }
        if (udpTransportMapping != null) {
            try {
                udpTransportMapping.close();
            } catch (IOException ex2) {
                udpTransportMapping = null;
            }
        }
    }

    public Variable snmpGet(String oid) throws Exception {
        try {
            PDU pdu = new PDU();
            // pdu.add(new VariableBinding(new OID(new
            // int[]{1,3,6,1,2,1,1,2})));
            pdu.add(new VariableBinding(new OID(oid)));
            pdu.setType(PDU.GET);

            // 以同步的方式發送 snmp get, 會等待target 設定的 timeout 時間結束後
            // 就會以 Request time out 的方式 return 回來
            ResponseEvent response = snmp.send(pdu, target);
            // logger.debug("PeerAddress:" + response.getPeerAddress());
            PDU responsePdu = response.getResponse();

            if (responsePdu == null) {
                logger.debug("Request time out");
            } else {
                Vector<?> vbVect = responsePdu.getVariableBindings();
                logger.debug("vb size:" + vbVect.size());
                if (vbVect.size() == 0) {
                    logger.debug(" pdu vb size is 0 ");
                } else {
                    Object obj = vbVect.firstElement();
                    VariableBinding vb = (VariableBinding) obj;
                    // logger.debug(vb.getOid() + " = " + vb.getVariable());

                    // logger.info("success finish snmp get the oid!");
                    return vb.getVariable();
                }
            }

        } catch (Exception e) {
            logger.error("Error", e);
            throw e;
        }
        return null;
    }

    public List<VariableBinding> snmpGet(List<String> oidList) throws Exception {
        try {
            PDU pdu = new PDU();
            pdu.setType(PDU.GET);
            for (String oid : oidList) {
                pdu.add(new VariableBinding(new OID(oid)));
            }

            // 以同步的方式發送 snmp get, 會等待target 設定的 timeout 時間結束後
            // 就會以 Request time out 的方式 return 回來
            ResponseEvent response = snmp.send(pdu, target);
            // logger.debug("PeerAddress:" + response.getPeerAddress());
            PDU responsePdu = response.getResponse();

            if (responsePdu == null) {
                logger.debug("Request time out");
            } else {
                logger.debug(" response pdu vb size is " + responsePdu.size());
                List<VariableBinding> datalist = new ArrayList<VariableBinding>();
                for (int i = 0; i < responsePdu.size(); i++) {
                    VariableBinding vb = responsePdu.get(i);
                    // logger.debug(vb.getOid() + "=" + vb.getVariable());
                    datalist.add(vb);
                }
                return datalist;
            }

        } catch (Exception e) {
            logger.error("Error", e);
            throw e;
        }
        return null;
    }
}

執行結果

2014-12-04 17:19:11,055 [main] DEBUG SnmpGet 145
 vb size:1
2014-12-04 17:19:11,083 [main] INFO  SnmpGet 50
 .1.3.6.1.2.1.1.3.0 = 1 day, 1:13:23.16
2014-12-04 17:19:14,084 [main] INFO  SnmpGet 53

2014-12-04 17:19:14,085 [main] DEBUG SnmpGet 145
 vb size:1
2014-12-04 17:19:14,086 [main] INFO  SnmpGet 56
 .1.3.6.1.2.1.1.1.0 = Linux server.maxkit.com.tw 2.6.32-431.el6.i686 #1 SMP Fri Nov 22 00:26:36 UTC 2013 i686

SNMP walk

這是使用 GETNext 的方式,當有下一個OID 時,就自動往下抓取,直到沒有資料為止。

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.snmp4j.CommunityTarget;
import org.snmp4j.PDU;
import org.snmp4j.Snmp;
import org.snmp4j.event.ResponseEvent;
import org.snmp4j.mp.SnmpConstants;
import org.snmp4j.smi.GenericAddress;
import org.snmp4j.smi.Integer32;
import org.snmp4j.smi.Null;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.OctetString;
import org.snmp4j.smi.Variable;
import org.snmp4j.smi.VariableBinding;
import org.snmp4j.transport.DefaultUdpTransportMapping;

public class SnmpGet {
    public static Logger logger = LoggerFactory.getLogger(SnmpGet.class
            .getName());

    private static int version = SnmpConstants.version1;
    private static String protocol = "udp";

    private static CommunityTarget target = null;
    private static DefaultUdpTransportMapping udpTransportMapping = null;
    private static Snmp snmp = null;

    public static void main(String[] args) {

        String ip = "192.168.1.8";
        String community = "public";
        int port = 161;

        Variable var = null;
        SnmpGet tester = new SnmpGet();
        // tester.snmpGet(ip, port, community, oidval);
        try {
            tester.connect(ip, port, community);
            logger.info("");
            logger.info("SNMP walk");

            vblist = tester.snmpWalk("1.3.6.1.2.1.1");
            for (VariableBinding vb : vblist) {
                logger.info("oid:" + vb.getOid() + ", var=" + vb.getVariable());
            }
        } catch (Exception e) {
            logger.error("Error:", e);
        } finally {
            tester.close();
        }
    }

    public void connect(String ip, int port, String community) throws Exception {
        String address = protocol + ":" + ip + "/" + port;
        // CommunityTarget target = SnmpUtil.createCommunityTarget(address,
        // community, version, 2 * 1000L, 3);

        target = new CommunityTarget();
        target.setCommunity(new OctetString(community));
        target.setAddress(GenericAddress.parse(address));
        target.setVersion(version);
        target.setTimeout(2 * 1000L); // milliseconds
        target.setRetries(3); // retry 3次

        try {
            udpTransportMapping = new DefaultUdpTransportMapping();
            // 這裡一定要呼叫 listen, 才能收到結果
            udpTransportMapping.listen();
            snmp = new Snmp(udpTransportMapping);

        } catch (Exception e) {
            logger.error("Error", e);
            throw e;
        }
    }

    public void close() {
        if (snmp != null) {
            try {
                snmp.close();
            } catch (IOException ex1) {
                snmp = null;
            }
        }
        if (udpTransportMapping != null) {
            try {
                udpTransportMapping.close();
            } catch (IOException ex2) {
                udpTransportMapping = null;
            }
        }
    }

    /**
     * 1)responsePDU == null<br>
     * 2)responsePDU.getErrorStatus() != 0<br>
     * 3)responsePDU.get(0).getOid() == null<br>
     * 4)responsePDU.get(0).getOid().size() < targetOID.size()<br>
     * 5)targetOID.leftMostCompare(targetOID.size(),responsePDU.get(0).getOid())
     * !=0<br>
     * 6)Null.isExceptionSyntax(responsePDU.get(0).getVariable().getSyntax())<br>
     * 7)responsePDU.get(0).getOid().compareTo(targetOID) <= 0<br>
     */
    public List<VariableBinding> snmpWalk(String targetOid) {
        OID targetOID = new OID(targetOid);

        PDU requestPDU = new PDU();
        requestPDU.setType(PDU.GETNEXT);
        requestPDU.add(new VariableBinding(targetOID));

        try {
            List<VariableBinding> vblist = new ArrayList<VariableBinding>();
            boolean finished = false;
            while (!finished) {
                VariableBinding vb = null;
                ResponseEvent response = snmp.send(requestPDU, target);
                PDU responsePDU = response.getResponse();

                if (null == responsePDU) {
                    logger.debug("responsePDU == null");
                    finished = true;
                    break;
                } else {
                    vb = responsePDU.get(0);
                }
                // check finish
                finished = checkWalkFinished(targetOID, responsePDU, vb);
                if (!finished) {
                    // logger.debug("vb:" + vb.toString());
                    vblist.add(vb);
                    // Set up the variable binding for the next entry.
                    requestPDU.setRequestID(new Integer32(0));
                    requestPDU.set(0, vb);
                }
            }
            // logger.debug("success finish snmp walk!");
            return vblist;
        } catch (Exception e) {
            logger.error("Error: ", e);
        }
        return null;
    }

    /**
     * check snmp walk finish
     * 
     * @param resquestPDU
     * @param targetOID
     * @param responsePDU
     * @param vb
     * @return
     */
    private boolean checkWalkFinished(OID targetOID, PDU responsePDU,
            VariableBinding vb) {
        boolean finished = false;
        if (responsePDU.getErrorStatus() != 0) {
            logger.debug("responsePDU.getErrorStatus() != 0 ");
            logger.debug(responsePDU.getErrorStatusText());
            finished = true;
        } else if (vb.getOid() == null) {
            logger.debug("vb.getOid() == null");
            finished = true;
        } else if (vb.getOid().size() < targetOID.size()) {
            logger.debug("vb.getOid().size() < targetOID.size()");
            finished = true;
        } else if (targetOID.leftMostCompare(targetOID.size(), vb.getOid()) != 0) {
            logger.debug("targetOID.leftMostCompare() != 0");
            finished = true;
        } else if (Null.isExceptionSyntax(vb.getVariable().getSyntax())) {
            logger.debug("Null.isExceptionSyntax(vb.getVariable().getSyntax())");
            finished = true;
        } else if (vb.getOid().compareTo(targetOID) <= 0) {
            logger.debug("Variable received is not "
                    + "lexicographic successor of requested " + "one:");
            logger.debug(vb.toString() + " <= " + targetOID);
            finished = true;
        }
        return finished;

    }
}

測試結果

2014-12-04 17:19:17,087 [main] INFO  SnmpGet 60
 SNMP GetList
2014-12-04 17:19:17,091 [main] DEBUG SnmpGet 182
  response pdu vb size is 3
2014-12-04 17:19:17,091 [main] INFO  SnmpGet 68
 oid:1.3.6.1.2.1.1.1.0, var=Linux server.maxkit.com.tw 2.6.32-431.el6.i686 #1 SMP Fri Nov 22 00:26:36 UTC 2013 i686
2014-12-04 17:19:17,092 [main] INFO  SnmpGet 68
 oid:1.3.6.1.2.1.1.3.0, var=1 day, 1:13:29.25
2014-12-04 17:19:17,092 [main] INFO  SnmpGet 68
 oid:1.3.6.1.2.1.1.5.0, var=server.maxkit.com.tw
2014-12-04 17:19:20,092 [main] INFO  SnmpGet 72

2014-12-04 17:19:20,093 [main] INFO  SnmpGet 73
 SNMP walk
2014-12-04 17:19:20,130 [main] DEBUG SnmpGet 276
 targetOID.leftMostCompare() != 0
2014-12-04 17:19:20,130 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.1.0, var=Linux server.maxkit.com.tw 2.6.32-431.el6.i686 #1 SMP Fri Nov 22 00:26:36 UTC 2013 i686
2014-12-04 17:19:20,130 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.2.0, var=1.3.6.1.4.1.8072.3.2.10
2014-12-04 17:19:20,131 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.3.0, var=1 day, 1:13:32.26
2014-12-04 17:19:20,131 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.4.0, var=Root <root@localhost> (configure /etc/snmp/snmp.local.conf)
2014-12-04 17:19:20,131 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.5.0, var=server.maxkit.com.tw
2014-12-04 17:19:20,132 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.6.0, var=Unknown (edit /etc/snmp/snmpd.conf)
2014-12-04 17:19:20,132 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.8.0, var=0:00:00.01
2014-12-04 17:19:20,132 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.2.1, var=1.3.6.1.6.3.11.2.3.1.1
2014-12-04 17:19:20,132 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.2.2, var=1.3.6.1.6.3.15.2.1.1
2014-12-04 17:19:20,133 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.2.3, var=1.3.6.1.6.3.10.3.1.1
2014-12-04 17:19:20,133 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.2.4, var=1.3.6.1.6.3.1
2014-12-04 17:19:20,133 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.2.5, var=1.3.6.1.2.1.49
2014-12-04 17:19:20,133 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.2.6, var=1.3.6.1.2.1.4
2014-12-04 17:19:20,133 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.2.7, var=1.3.6.1.2.1.50
2014-12-04 17:19:20,133 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.2.8, var=1.3.6.1.6.3.16.2.2.1
2014-12-04 17:19:20,133 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.3.1, var=The MIB for Message Processing and Dispatching.
2014-12-04 17:19:20,134 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.3.2, var=The MIB for Message Processing and Dispatching.
2014-12-04 17:19:20,134 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.3.3, var=The SNMP Management Architecture MIB.
2014-12-04 17:19:20,134 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.3.4, var=The MIB module for SNMPv2 entities
2014-12-04 17:19:20,134 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.3.5, var=The MIB module for managing TCP implementations
2014-12-04 17:19:20,134 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.3.6, var=The MIB module for managing IP and ICMP implementations
2014-12-04 17:19:20,134 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.3.7, var=The MIB module for managing UDP implementations
2014-12-04 17:19:20,134 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.3.8, var=View-based Access Control Model for SNMP.
2014-12-04 17:19:20,135 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.4.1, var=0:00:00.01
2014-12-04 17:19:20,136 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.4.2, var=0:00:00.01
2014-12-04 17:19:20,137 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.4.3, var=0:00:00.01
2014-12-04 17:19:20,138 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.4.4, var=0:00:00.01
2014-12-04 17:19:20,139 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.4.5, var=0:00:00.01
2014-12-04 17:19:20,143 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.4.6, var=0:00:00.01
2014-12-04 17:19:20,143 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.4.7, var=0:00:00.01
2014-12-04 17:19:20,144 [main] INFO  SnmpGet 77
 oid:1.3.6.1.2.1.1.9.1.4.8, var=0:00:00.01

SNMP Asynchronous Get

如果在程式中,無法在發送 snmp request 之後,直接等待結果,例如在 UI 界面上發送 request,但 UI 無法被 blocking 以等待 response 或 timeout 的狀況下,我們就必須要使用非同步 SNMP Get。

程式中主要是利用 ThreadPool,以 multithread 的方式,在背景中發送 request,並以 event listener 作為 call back function。

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.snmp4j.CommunityTarget;
import org.snmp4j.MessageDispatcherImpl;
import org.snmp4j.PDU;
import org.snmp4j.Snmp;
import org.snmp4j.event.ResponseEvent;
import org.snmp4j.event.ResponseListener;
import org.snmp4j.mp.MPv1;
import org.snmp4j.mp.MPv2c;
import org.snmp4j.mp.MPv3;
import org.snmp4j.mp.SnmpConstants;
import org.snmp4j.smi.GenericAddress;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.OctetString;
import org.snmp4j.smi.VariableBinding;
import org.snmp4j.transport.DefaultUdpTransportMapping;
import org.snmp4j.util.MultiThreadedMessageDispatcher;
import org.snmp4j.util.ThreadPool;
import org.snmp4j.util.WorkerPool;

public class SnmpClientAsync {
    public static Logger logger = LoggerFactory.getLogger(SnmpClientAsync.class
            .getName());

    private static int version = SnmpConstants.version1;
    private static String protocol = "udp";

    private static CommunityTarget target = null;
    private static DefaultUdpTransportMapping udpTransportMapping = null;
    private static Snmp snmp = null;
    private WorkerPool threadPool = null;

    public static void main(String[] args) {

        String ip = "192.168.1.8";
        String community = "public";
        int port = 161;

        SnmpClientAsync tester = new SnmpClientAsync();
        try {
            tester.connect(ip, port, community);
            logger.info("");
            logger.info("SNMP GetList");
            List<String> oidList = new ArrayList<String>();
            oidList.add(".1.3.6.1.2.1.1.1.0");
            oidList.add(".1.3.6.1.2.1.1.3.0");
            oidList.add(".1.3.6.1.2.1.1.5.0");

            tester.snmpGet(oidList);

            // 非同步,必須等待一段處理時間
            Thread.sleep(3*1000);
        } catch (Exception e) {
            logger.error("Error:", e);
        } finally {
            tester.close();
        }
    }

    public void connect(String ip, int port, String community) throws Exception {
        String address = protocol + ":" + ip + "/" + port;

        target = new CommunityTarget();
        target.setCommunity(new OctetString(community));
        target.setAddress(GenericAddress.parse(address));
        target.setVersion(version);
        target.setTimeout(2 * 1000L); // milliseconds
        target.setRetries(3); // retry 3次

        try {
            threadPool = ThreadPool.create(ip + "SNMPWorkPool", 2);
            MultiThreadedMessageDispatcher dispatcher = new MultiThreadedMessageDispatcher(
                    threadPool, new MessageDispatcherImpl());

            udpTransportMapping = new DefaultUdpTransportMapping();

            snmp = new Snmp(dispatcher, udpTransportMapping);
            snmp.getMessageDispatcher().addMessageProcessingModel(new MPv1());
            snmp.getMessageDispatcher().addMessageProcessingModel(new MPv2c());
            snmp.getMessageDispatcher().addMessageProcessingModel(new MPv3());
            snmp.listen();
        } catch (Exception e) {
            logger.error("Error", e);
            throw e;
        }
    }

    public void close() {
        if (snmp != null) {
            try {
                snmp.close();
            } catch (IOException ex1) {
                snmp = null;
            }
        }
        if (udpTransportMapping != null) {
            try {
                udpTransportMapping.close();
            } catch (IOException ex2) {
                udpTransportMapping = null;
            }
        }
        if (threadPool != null) {
            threadPool.stop();
            threadPool = null;
        }
    }

    public void snmpGet(List<String> oidList) throws Exception {
        try {
            PDU pdu = new PDU();
            pdu.setType(PDU.GET);
            for (String oid : oidList) {
                pdu.add(new VariableBinding(new OID(oid)));
            }

            snmp.send(pdu, target, null, listener);
        } catch (Exception e) {
            logger.error("Error", e);
            throw e;
        }
    }

    public void printResponse(List<VariableBinding> datalist) {
        for (VariableBinding vb : datalist) {
            logger.info("oid:" + vb.getOid() + ", var=" + vb.getVariable());
        }
    }

    ResponseListener listener = new ResponseListener() {
        public void onResponse(ResponseEvent event) {
            ((Snmp) event.getSource()).cancel(event.getRequest(), this);
            PDU response = event.getResponse();
            PDU request = event.getRequest();
            //logger.debug("[request]:" + request);

            if (response == null) {
                logger.debug("[ERROR]: response is null");
            } else if (response.getErrorStatus() != 0) {
                logger.debug("[ERROR]: response status"
                        + response.getErrorStatus() + " Text:"
                        + response.getErrorStatusText());
            } else {
                logger.debug("Received response Success!!!");
                List<VariableBinding> datalist = new ArrayList<VariableBinding>();
                for (int i = 0; i < response.size(); i++) {
                    VariableBinding vb = response.get(i);
                    logger.debug(vb.toString());
                    datalist.add(vb);
                }
                printResponse(datalist);
            }
        }
    };

}

測試結果

2014-12-08 10:18:07,548 [main] INFO  SnmpClientAsync 49

2014-12-08 10:18:07,581 [main] INFO  SnmpClientAsync 50
 SNMP GetList
2014-12-08 10:18:07,607 [192.168.1.8SNMPWorkPool.0] DEBUG SnmpClientAsync 151
 Received response Success!!!
2014-12-08 10:18:07,607 [192.168.1.8SNMPWorkPool.0] DEBUG SnmpClientAsync 155
 1.3.6.1.2.1.1.1.0 = Linux koko.maxkit.com.tw 2.6.32-431.el6.i686 #1 SMP Fri Nov 22 00:26:36 UTC 2013 i686
2014-12-08 10:18:07,610 [192.168.1.8SNMPWorkPool.0] DEBUG SnmpClientAsync 155
 1.3.6.1.2.1.1.3.0 = 4 days, 18:12:20.49
2014-12-08 10:18:07,611 [192.168.1.8SNMPWorkPool.0] DEBUG SnmpClientAsync 155
 1.3.6.1.2.1.1.5.0 = koko.maxkit.com.tw
2014-12-08 10:18:07,611 [192.168.1.8SNMPWorkPool.0] INFO  SnmpClientAsync 133
 oid:1.3.6.1.2.1.1.1.0, var=Linux koko.maxkit.com.tw 2.6.32-431.el6.i686 #1 SMP Fri Nov 22 00:26:36 UTC 2013 i686
2014-12-08 10:18:07,611 [192.168.1.8SNMPWorkPool.0] INFO  SnmpClientAsync 133
 oid:1.3.6.1.2.1.1.3.0, var=4 days, 18:12:20.49
2014-12-08 10:18:07,612 [192.168.1.8SNMPWorkPool.0] INFO  SnmpClientAsync 133
 oid:1.3.6.1.2.1.1.5.0, var=koko.maxkit.com.tw

Reference

Java實現snmp的get和walk代碼示例

Introduction to snmp4j

2014/12/13

國姓爺的寶藏 - 蘇上豪

會知道蘇上豪這位醫師作家,是因為這篇借刀醫人的開膛史文章的介紹,開膛史這本書買了但還沒有看,先看了這本國姓爺的寶藏,這本書是以國姓爺鄭成功為引子,藉由國姓爺後代尋找當時留下寶藏的過程,介紹了台灣各地的特殊小吃,以及一些特別的景點。

如果想要像電影「國家寶藏」那樣有刺激的過程,可能會有點小失望,整本小說最有趣的地方,是在描述尋寶故事起源的序曲中,如果能用多一點的篇幅描述這一段就好了。

平常看的書,大部分都是由外語翻譯來的小說,中文作者的小說並不多,雖然像前一段所說的那樣,故事的高低起伏並不大,但讀起來還算是輕鬆愉快,不會因為人物變多,而有看不懂的感覺,書本前面的人物關係表幫了大忙,稍微翻一下,就可以回想起來故事的大綱。

如果尋寶的那一段,要更刺激,我覺得可以設計讓鄭成功的直系與旁系後代兩邊互相對抗爭奪寶藏,這樣應該會比一個鄭家後代委託尋寶的單線劇情還來得有趣。

或許可以讓這兩個後代,各成立一個組織,或甚至讓他們承襲鄭家流傳下來的武術,發展出兩套不同的武功,這樣就可以讓對抗的過程更戲劇化。

單就小說本身,雖然我的評語是平淡無奇,但仍然還算是一本容易閱讀的小說,建議讀者可以把這本書當作一個小品,因為這還算是很通順易懂的一個作品。就我來說,一位醫師也能寫出這樣的小說,一方面是欽佩,一方面是驚奇,我只能寫寫讀者不多的 blog,沒辦法寫出一個像樣的小說故事出來。

2014/12/12

秦始皇:一場歷史的思辨之旅 - 呂世浩

台灣大學在Coursera發布的課程中,受到最多學生迴響的,有一個是葉丙成老師的機率,另一個就是呂世浩老師的秦始皇coursera 中國古代歷史與人物--秦始皇,其中機率結合了線上遊戲的體驗,由學生分組出題的方式,在最近得到了創新教學冠軍。臺大電機線上遊戲學習PaGamO,奪全球創新教學冠軍!

這本書是呂世浩老師藉由秦始皇這個主題,告訴大家我們長久以來學習歷史的方式,讓我們忘記了一個最重要的事,學習的目的不是只有背誦下來的知識,而是要去思考,如何運用這些知識,成為知識的主人。

學習歷史的重點,不在背誦與記憶,最重要的是學習做人處事的方法,面對事情的時候,決策不會只有一種,也沒有標準答案,我們應該在了解歷史事件之後,反思當時的情況,並以設身處地的方式,假設自己在那個時空下,會做出什麼決定。用這個方式去認識與了解其他人,就能對其他人理解多一些。

如果沒有買書,也沒有時間去 MOOC 上課,可以先看一下這個演講影片:




這篇文章:《秦始皇:一場歷史的思辨之旅》教我的七件事,也有把一些重要的句子節錄出來。

根據呂老師說明「思辨」的方法與建議,我也對這一本書提出了一些我認為該再進一步往下思考的觀點。

唧唧 是歎息聲,不是織布機

閱讀這本書的第一個課程,就是先知道自己被機械式教育的毒害有多深,「唧唧復唧唧,木蘭當戶織。」 唧唧在課本裡面的解釋是織布機的聲音,幾乎所有人都會這樣回答,可是下一句「不聞機杼聲,惟聞女歎息」,很明確地告訴了讀者,沒有織布機的聲音阿!唧唧是嘆息聲。

是啊,為什麼我們從來都沒有懷疑過這個事情,我們該怪罪國文老師嗎?不對,問題在於,我們的教育模式,太過於強調標準答案,認為只有標準答案才能「正確」地將人分出高下。

呂老師在影片中也提到,為什麼我們沒有一門課,是教大家該如何選擇人生的伴侶,因為這一件事對我們一生的影響,遠比學習其他知識重要很多。

「背誦」是所有學問的基礎

雖然作者告訴我們,要以思辨的方法閱讀歷史,但思辨的背後基礎,還是要「背誦」,這是所有學問的基礎,我們的問題是,在課業與升學的壓力下,忘記了一些事情,忘記了我們該更深入認識與了解古人,用呂老師提醒的方式,將知識更進一步內化到心中。

幾乎所有的學問都是這樣,會先經過一段背誦的時期,再因為思辨與了解,會讓我們自然而然地把這些知識記憶起來,我們欠缺的,是再進一步地理解、運用與思考,而這些學問也會自然而然地進入長期記憶,我們也會慢慢地變成這個領域的專家。

經驗累積所帶來的副作用

我們常常會以自己的經驗去分析與判斷,寫程式更是如此,最直覺的解決方案,往往是自己最熟悉的方法,但這種模式並不一定永遠適用,有時就是會遇到所有的經驗與方法都不可行的狀況,一個完全沒有經驗的人,可能會提出一個有經驗的人永遠想不出來的方法。

這時候就會發生天降奇兵的狀況,老兵也得要認老,慢慢地就會發生「老兵不死,只是凋零」的窘境。

歷史就像是一個古人的經驗,在我們以理性分析的方法,認識古人的時候,就像是已經吸取了古人的經驗,在我們遇到問題時,如果腦袋裡一下子有好幾個古人跳出來,告訴你該怎麼處理,這時候,我們到底該怎麼辦呢。

就算是完全沒有讀過書的人,遇到事情的時候,也會得到周圍所有人的經驗與建議,在這樣的狀況下,該相信誰呢?

或許在這樣的時候,也只能反璞歸真,回頭相信自己的直覺。真的想太多,一直無法做下決定的人,可能就會在眾多意見與自己的想法之間繞圈圈,進入一種無窮迴圈式的思考模式。

其實不管什麼決定,帶來的結果與影響都是不可以且無法預先得知的,我們總是要踏出那一步,才知道最後的結果。做出決定後,就要放輕鬆,然後再做好準備,面對下一個遇到的人生課題。

當呂老師一直以這樣理性的方式分析與了解歷史人物,相信他的腦袋裡,同時會有很多個歷史人物會在遇到事情的時候跳出來給他建議,我很好奇在他遇到自己人生的分歧點時,他會如何面對與處理自己的人生呢?

能下決定的只有你自己

在自己、朋友、家人,再加上歷史人物的經驗之間,最終的決定還是在自己手上,就算是再怎麼困難的抉擇,每一件事情都會有最終決定的期限,等到倒數時間終止的那一刻,還是得做出你自己的決定。

2014/12/8

改變世界的九大演算法 - John MacCormick

本書所介紹的九大演算法是:搜尋引擎的索引(search engine indexing)、網頁排序(page rank)、公鑰加密(public-key cryptography)、錯誤更正碼(error-correcting codes)、模式辨識(pattern recognition,如手寫辨識、聲音辨識、人臉辨識等等)、資料壓縮(data compression)、資料庫(databases)、數位簽章(digital signature)。

寫程式的人很多,做IT工作的也很多,但並不是每一個人都能了解這些常用演算法背後的精神與原理,我也跟一般 IT 工程師一樣,沒有專業到完全了解這些演算法的來歷,沒有辦法把每一個演算法講出來,還能讓 dummy user 聽得懂。

本書的推薦序也講得很明白,要撰寫甚至出版這本書,本身就有很高的風險,科普書的禁忌是:出現的算式越多,賣得越差,所以這本書的目標讀者該是給像我們這樣的 IT 工程師閱讀,但如果是剛畢業沒多久的工程師們,應該都還有印象,在演算法課程時鴨子聽雷的窘樣。

這似乎也多少註定了書本的命運,銷售量肯定不會很高。但我還是強烈建議,應該花時間去把這本書看一看,這可讓我們對關聯式資料庫、Google搜尋等等項目,有更深一層的認識。專業工作者的一項最重要的功能,就是在遇到一些技術上要實作的問題時,能提出一套解決方案,而這本書的知識,就是你備而不用的專業背景知識。

接下來,我只討論「公鑰加密」這個章節,其他的部份,就留待讀者自己去看書了。「公鑰加密」這章的副標題是:用明信片寄送祕密,這個比喻非常貼切,因為網路上的資料,對所有網路節點來說,都是明白且清楚的,把資料放在網路上傳送,也就等同於我們寫了一張明信片投遞出去,所有經手這張明信片的人都能看到,上面寫了什麼。

最直覺的解決方式,就是收送雙方預先協商出一個密碼,但這樣會有另一個問題,當面對另一個不認識的人,我們就沒辦法預先協商密碼了。

作者用顏料混色法,來解釋應該要怎麼處理

  1. A 與 B 各自選擇一個「個人色」
  2. A 與 B 其中一位,公開宣佈一個不同的新顏色為「公共色」
  3. A 與 B 各自將公共色與個人色混合,製造出一個「公共個人混色」
  4. A 取得 B 的「公共個人混色」,再加入自己的「個人色」。同時間 B 取得 A 的「公共個人混色」,再加入自己的「個人色」。結果兩個人製造出完全一樣的三色混色結果。

於是這最終的三色混漆,就成了 A 與 B 的共同祕密混漆。由於 C 不知道 A 與 B 的「個人色」,因此就無法破解「公共個人混色」

電腦不是混色,而是將顏色改為數字,混色改為乘法。最有明的公鑰加密方法是 RSA。了解這個章節搭配上第九章數位簽章的內容,就可以知道,我們怎麼在公開的 Internet 環境中,製作一個在任意的 A 與 B 兩地之間,安全地傳送資料的計算環境。

在我們學習網路程式設計時,通常會連帶學到,區域網路的廣播特性,還有網路監聽側錄 sniffer 程式的使用,因為撰寫網路程式就是在跟封包資料奮戰,我們常常得一個一個 byte 去觀察收送兩端傳送資料的正確性,才知道自己寫的程式到底對或錯。

sniffer 技巧如果用在 hacker 行為上,只要在網路上經過的節點上放置 sniffer 程式,就可以錄製到所有的封包資料,雖然一般使用者沒辦法想像網路的傳輸協定,但都能理解到,有個監聽者在監聽資料的狀況下,沒有資料加密機制,就等於拿一張明信片在上面寫字,告訴大家我在講什麼。

還記得以前的宿舍網路,當時還是用同軸電纜,網路一段一段加上 repeater,當時也是 BBS 流行的時代,所以只要在其中有一台電腦裝上 sniffer,就可以看到大家在 BBS 上跟妹妹 talk 的肉麻對話。

雖然現在的集線器已經都是 switch 而不是 hub,switch 不會將某個 port 的資料轉送到其他所有 port 上,但是 hacker 還是可以透過 ARP 的方式,製造出 man-in-the-middle 的環境,就能取得特定 IP (range) 的進出封包,資料加密機制在現今有缺陷的網路協定上,是不可或缺的技術。

博客來:改變世界的九大演算法:讓今日電腦無所不能的最強概念

2014/12/1

Google 模式 - Eric Schmidt & Jonathan Rosenberg

這本書是 Eric Schmidt 與 Jonathan Rosenberg 所撰寫,內容是說明 Google 的企業文化,Larry Page 在推薦序中指出,Google 人就該有自主思考的力量,每個人都該大膽思考,探尋可能,解決問題,尋找答案。

Google 的文化也不是在公司開門的第一天就建立起來了,我們該有開放的態度,慢慢地去調整與建立一個屬於我們自己的企業文化。接下來,我只把一些我想再討論的議題 highlight 出來,並嘗試進行一些討論,其中會夾雜著我的個人意見。

持續賺錢的方法

大家都知道 Google 最賺錢的業務就是 Adwords,也因為這個能夠持續獲利的金雞母,讓 Google 可以貫徹自己的企業理念,可以不斷賠錢去實驗一大堆高風險的新專案。

但在這樣思考的同時,我們也該想到,如果 Google 天生沒有擁抱創新的原生泥漿,也可能不會誕生一個 Adwords。有點雞生蛋或是蛋生雞的問題。

但很明確的是,Google 在 2002 年以前都還是用最重要的 100個專案的表單來進行資源分配與管理,也就是說,在公司發展的初期,受限於當時的時空背景,Google 還是得用傳統的方式,集中發展的資源在最高決策者認定最有發展潛力的專案上。

一直等到穩定獲利的時空下,才來談 70/20/10 的資源分配法則,這都是為了讓公司規模在快速膨脹下,還能夠保有企業內部創業的原生文化才提出的口號與決定,20% 的資源放在有初步成果的新產品,10% 投入在全新的專案。

10%的資源投資很適當,還有一個道理:創造力熱愛資源受限(creativity loves constraints)。真正有效的想法,反而在受限資源的條件下,讓人可以快速地切入重點。

別聽河馬的意見

河馬也就是公司裡面最高薪資的人的意見,但是決策品質基本上跟薪資高低無關,只要是一個有說服力的理論,就能勝出。

Adword 發展初期遇到了「河馬」布林以及蘇利哈.拉瑪斯兩個點子的對抗,而爭辯的最後,布林的方式被放棄了,原因是布林了解討論中提出的資料,如果換成不了解的河馬,就可能會以職位強壓進行他自己提出的策略。

決策的討論要以資料為基礎進行討論,收集資料成了最重要的前提,如果是大家都沒有做過的事情,沒有解決過的議題,很明顯地就會落入不容易找到佐證資料的狀況。

如果是全新的想法,就可能要做 prototype 來實驗,例如 Google Books 的想法,一開始是用簡單的掃描機制去計算,掃描每一本書所需要耗費的時間,以此推論整個圖書館需要處理多久。

適應改變的能力

人才招募是最重要的事務,找對了人,就能在環境中得到相乘的效果,至於什麼樣的人才,對公司來說是最佳的人才,不同的公司可能有不同的答案,有些公司需要即時的人力,他考慮的只要有基本的程式技能就好了,不需要員工想太多,反正案子進來了,配合客戶把客戶照顧好,就沒有問題了。

在前一次進行面試時,應試者問了我一個問題,你認為我欠缺了什麼樣的能力,應該補足什麼樣的技能?我想了一下,給他的答案是,要擁有「適應改變的能力」。

我給他的理由是,在發展產品的過程中,有很多功能是在公司內部發想,然後進行開發,接下來推送到客戶端,根據回應進行產品功能修正。

什麼樣的功能對產品來說是好的?如果是 Google,可能就是用 20% 的時間先去開發一個 prototype,接下來在內部推動,並取得其他人的回饋意見,最終決策者會判定這樣的修正是不是可以被接受。

20% 的時間事實上是 120%

在沒有看過這本書以前,我們已經聽過 Google 人可以使用 20% 的時間自己進行專案不需要老闆的同意,但事實上這 20% 的 Free Time,還是有一些遊戲規則在背後的。

首先是 20% 的時間不代表每一星期都可以使用星期五作為 Free Time,而是在不影響現有工作的前提下,才能進行自己的專案,止於這 20% 的時間,並不一定就是在公司上班時間的 20%,而是要包含自己的時間。

換句話說,公司鼓勵內部創業,但自己的事情要先做好,而且內部創業,有想法之後,必須自己找到認同你的想法的人加入你的專案,取得別人的認同是首要條件。

至於時間,有些人是利用一個暑假,或是週六週日的時間,沒有人規定可以放掉手邊的工作,直接進行自己的專案。也就是說,20% 的 Free Time,在發展初期可能是 120%,一直要等到有初步成果開花結果下,公司才認定可以分配資源繼續進行下去。

使用 email 的方法

在處理對應客戶的問題的習慣下,我常常會做以下的事情,接收到問題,嘗試去解決並尋找答案,在一天內進行回應,我非常認同,每一個人做事都該盡可能地在很短的時間內,進行回應,就算是告訴客戶,你已經在了解中,但還不知道怎麼解決,這也是一種良性的回應。經常清除 email 收件匣這個建議,就跟快速回應是一樣的,因為要快速回應,我們就不應該常在收件匣裡面看到有還沒有處理過的 email。

讓要求事項很容易後續追蹤這個建議,讓我想到,gmail 的基本功能,其實就是圍繞著這個想法,收到郵件時,首先是過濾器,可輕鬆地設定標籤,決定優先順序,並排除掉 promo 或是垃圾信。接下來是閱讀與處理,如果閱讀後,認定需要追蹤處理,則可以歸類到 todo 的項目中。至於 Draft 也像是一種 todo,還沒有寫完的回信,都是必須要盡快處理的事項。

被挑戰的準備

正如同前面提到的適應改變的能力,我常常在等待我的意見被挑戰與否定,原因是一方面我不認為自己永遠是對的,如果只因為常常主導意見的角色,而壓抑了其他人的聲音,這並不是個健康的互動方式。

我承認有些時候,會因為時程的壓力,我必須進行強勢的時間安排與規格的主導,但在這樣的會議過程中,如果有不一樣的聲音,而且又有絕佳的理由與論點,這是非常有幫助的。如果我可以在還沒有實現的一開始,就馬上調整方法與作法,相對來說就節省了很多成本的浪費。

所以我必須告訴自己說,要有被挑戰的準備,而相對來說,也要做好準備挑戰其他人。

擁抱改變

我認定自己在專案管理上,一直以來常常在進行動態調控,因為我並沒有辦法在產品發展的初期,就知道會遇到什麼困難,因此我必須不斷地根據開發的狀況,遇到的問題與解決的狀況,動態調控人力的分配與資源,甚至有時候還需要更深入去了解問題,並在沒有在該專案上寫過任何一行 code的狀況下,嘗試去想像 programmer 可能會怎麼去寫這一段的程式邏輯,而因為這樣的邏輯缺陷,而造成某些問題。

我認為自己該「擁抱改變」,甚至該擁抱不間斷地改變,這改變並非一夕之間,但確實每天都在發生。企業生命體也該如此,每天持續地做出更適當的決定,在能持續生存的前提下,持續鍛鍊出更健康的公司體質。

如果你的出發點是個人的利益得失,那每天就得帶著鋼盔與龜殼做事,期待不會被子彈掃射,如果出發點是公司的成敗,那麼就該擇善固執,認為是對的事情,就得去做,並嘗試證明你的意見是對的。

2014/11/19 「關於把Google模式用在台灣,我想說的是...」
(轉)從書中Google的實際故事了解google獨樹一幟的管理哲學
《Google模式》:Eric Schmidt 教你 Google 人怎麼使用電子郵件
《Google 模式》:在網路時代找工作如同衝浪,讓技術洞察者為你指引明燈
Google人才招募九大守則,不想解雇員工,一開始就別錄取他
Google模式(讀後心得)
偷學《Google 模式》!學會 70/20/10 法則,建立說 Yes 的企業文化
《Google模式》談人才 -- 招募是最重要的事務!