haskell 확장 NamedFieldPuns ( record puns 라고 불리는듯 )

메뉴얼 참고.
이거 알아두면 편하겠군?


{-# LANGUAGE NamedFieldPuns #-}

-- 이런 레코드 타입이 있다고 치자. 보통 함수에서는 모든 필드를 참조할
-- 필요가 없으니 패턴매칭으로 필요한 필드값만을 꺼내서 쓰는 식의 코딩이
-- 된다.
data C = C {
      a :: Int,
      b :: Int,
      c :: Int
      } deriving (Show)

-- 레코드 타입의 패턴매칭 기본 문법은 아래와 같다.
--   TypeName{fieldName=varName, ..}
f C{a=foo,b=bar} = (foo,bar)
       

-- 하지만 타이핑이 귀찮으니 보통 이런식으로 적을때 필드이름과
-- 변수이름을 같은 이름을 쓰는게 일반적.
g C{a=a, b=b} = (a,b)


-- NamedFieldPuns 확장을 쓴다면 필드이름과 변수이름이 같을경우 짧게
-- 타이핑하는게 가능해진다. 이런 확장을 record punning 이라고 칭하는
-- 모양이다.
h C{a,b} = (a,b)


-- puns 는 다른 패턴과 섞어쓰는것도 가능
i C{a, b=1} = 1
i C{a, b=2} = 2
i C{c}      = c


-- 패턴매칭이 적용되는 다른부분(let등)에도 적용가능
j = let a = 1
        b = 2
        c = 3
    in C {a,b,c}

mercurial 을 ssh 통해서 사용하기 - 좃스팟에 썼던 글 백업

유닉스 등에서 간단한 사용법 path 를 줄때 // 가 들어간다는것만 기억하삼

ssh 를 통한 clone

hg clone ssh://누구@어느호스트//경로/경로

호스트와 path 사이에 / 가 두개 들어간다는것만 기억해두자.
~id 를 쓸때는 모양이 좀 달라져서 / 하나로 충분. 즉 ssh://yoonkn@192.168.0.7/~yoonkn/emacs 와 ssh://yoonkn@192.168.0.7//home/yoonkn/emacs 는 동일 ( 물론 ~yoonkn 이 /home/yoonkn 일때 )

그외 상세한것은 http://hgbook.red-bean.com/hgbookch6.html 를 읽어보면 될듯

win32 에서 간략히 쓰는 방법. 안전하지는 않다.

만 약 win32 환경이라면 키를 만들고 agent 띄우는 삽질을 해야 하는데.. 이거 짱나서 못할짓이니 좀 엄하지만 암호를 그냥 커맨드라인에서 쳐버리자. 편한게 좋은거지... 윈도머신까지 정말 안전하다는 보장이 있다면 ini 등에 -pw 옵션까지 박아버리는 수도 있지만 이건 좀 모양이 안좋다. 환경변수에서 ssh client 를 가져가는 방법이 있으면 좋겠는데... 암호치는것 누가 등뒤에서 봐도 좀 곤란한 일이니까.. 흠 메뉴얼을 뒤져보고 만약 없다면 적당한 배치파일을 만들자.

안전하지 않지만 편리한, plink 를 통한 ssh 통신 방법

hg clone -e "plink -pw 암호" ssh://누구@어느호스트//경로/경로

추가. push/pull 이 생각처럼 자주 하는일이 아니네. 그냥 ssh 날로 쓰고 매번 암호 물어볼때마다 쳐주는것도 할만 하다. plink 가 필요에 따라 똘똘하게 대화창으로 암호묻는것도 맘에 든다.

리눅스 서버에서 특정 id 의 ssh 접근을 ip 별로 블럭하기

위 에서 적은대로 사무실의 내 데스크탑(우분투)를 임시로 메인 리파지토리로 사용하고 있다. 그런데 윈도에서 접근하려면 아주 성가시므로 암호를 아예 없애거나 간단한 단어를 쓰려고 생각중인데.. 따라서 내가 원하는 몇몇 호스트를 제외하고는 ssh 접근을 막아야만 했다. 처음엔 간단히 /etc/hosts.allow 와 /etc/hosts.deny 를 수정하면 되겠지 했는데 이게 잘 안되더라.. 결국 구글링해서 적당한 방법을 찾아내고 여기 적어둔다.

http://www.cyberciti.biz/tips/openssh-root-user-account-restriction-revisited.html 를 참고하자. 내가 했던 절차를 적어둔다.

1. /etc/pam.d/ssh 에서 account  required     pam_access.so 부분의 주석을 벗겨줬다.
2. /etc/init.d/ssh restart 를 이용 sshd 를 재시작 해줬다.
3. /etc/security/access.conf 에 다음 내용을 추가했다. foo 사용자의 접근을 111.111.111.111, 222.222.222.222 를 제외한 모든 장비로부터 막는 예제이다. 실제 사용을 위해서는 로컬호스트도 풀어주고 해야겠지...
   

  - : foo : ALL EXCEPT 111.111.111.111 222.222.222.222

추가. UbuntuFireWall 을 쓰면 비교적 쉽게 이런 세팅이 가능하다. hg serve 명령으로 여러개의 리파지토리 서빙하기 참고.

pageant 를 이용해서 암호 입력 생략하기 (windows)

내래 agent 쓰는걸 별로 안좋아하고 매번 암호치는 놈이니 이렇게 쓰지는 않지만 그냥 적어둔다. 언제 기호가 바뀔지 모르지.

이하는 사전작업. 자신의 공개키/비밀키를 만들고 서버에 공개키를 등록하는 과정.

1. windows 에서 putty 깔렸다 치고
   
2. puttygen 으로 적절히 키 생성.
   
3. puttygen 에 생성된 공개키를 서버(여기선 mercurial 리파지토리가 될 놈이겠지)의 ~/.ssh/authorized_keys 에 추가. 없으면 새로 생성. 이 ~.ssh 이하는 퍼미션이 700 또는 600 으로. group 이나 others 에 권한이 있다면 에러가 날 가능성이 있다. 물론 공개키를 로컬에도 남겨둬야 여기저기 써먹지. 난 주로 c:\public.key 에 남긴다.
   
4. puttygen 에서 비밀키를 저장하자. 난 c:\private.ppk 란 이름 주로 사용

이하는 접속할때마다 해줄 작업. 당연히 클라이언트(여기선 윈도) 에서만 해주면 된다.

1. pageant 를 띄워서 add key 로 c:\private.ppk 추가. 필요하다면 ppk 로딩하는 배치파일을 시작프로그램 넣어서 자동화. 뭐 필요할때마다 띄워도 충분. 보통 키생성시에 passphrase 를 걸어줄텐데 그럴경우 자동시작 하기가 좀 꺼려진다...
   
2. cmd 창을 열어서 plink 가 pageant하고 통신을 하는지 확인해보자. plink -i private.ppk yoonkn@111.111.111.111 hg version
3. 끝. putty GUI 버전을 자주 쓴다면 적절히 세팅.

ssh 통해서 mercurial 을 쓸때 통신 데이타 압축하기

hgbook 을 보니 mercurial 은 로컬에 델타데이타를 저장할때 gz 형식을 쓰고 hg serve 를 통해서 http 통신을 탈땐 bz2 방식으로 압축을 하는데 ssh 를 탈때는 압축을 하지 않는다고 한다. ssh 가 압축기능을 가지고 있다고 하기 때문인데 이럴경우 ssh 또는 plink 에 -C 옵션을 줘야 한다... Mercurial.ini 등에 ssh 설정이 있을텐데 -C 를 추가하도록 하자. tortoise hg 는 이걸 기본적으로 안해주더라. 자잘하게 손이 많이 가네...

리눅스에서 ssh agent 사용해서 암호입력 생략하기

위에 윈도에서 하는 방법을 적고 나니 이것도 같이 적어줘야 겠다는 생각이 드네. http://wiki.kldp.org/wiki.php/UsingSshAgent 에 정리가 잘되어있으니 참고하자.

1. ssh-keygen 으로 키 생성.
2. ssh-copy-id yoonkn@111.111.111.111 명형으로 공개키 추가. 물론 pageant 때 처럼 수작업 해줘도 되겠지.
3. 끝. 이제 ssh yoonkn@111.111.111.111 ls 로 확인해보자.

C++ 바이너리 패킷 읽고 쓰는 클래스

이런게 필요해서 간단히 만들어봤다.
초안이라 버그가 남아있을테지만 나중에 버그수정후에도 여기 업데이트 할지는 모르겠네.




이건 bufrw.hpp 초안이라 그냥 헤더에 때려박았다. 원래 write<T> read<T> 식으로 템플릿으로 해볼까 했었는데 바이트오더 때문에 좀 귀찮아서 노가다질로. memcpy 쓰면 될부분에 포인터로 하나씩 복사한다거나.. 루프돌려야 할부분에 리커시브 돌린다거나(이건 뭐 최적화키면 전혀 문제 안되지만) 등등 막짠부분이 많으니 주의하자.

펼쳐두기..

// 바이너리 패킷을 다룰일이 생겨서 간단히 만들어봤다.
// 
// writer 는 write_T 로 줄줄이 값을 쓰고 나중에 만들어진 버퍼를
// 꺼낼수있도록 했고
//
// reader 는 버퍼를 생성시 받아서 read_T 로 값을 적절히 꺼내고 나중에
// 남은 버퍼를 꺼낼수 있도록 만들었다.
//
// 대강 적어본 초안이라 테스트는 전혀 안되었고 나중에 버그나오면
// 수정해가면서 쓰면 되겠지.

#ifndef BUFRW_HPP
#define BUFRW_HPP

#include <winsock2.h>
#include <vector>
#include <stdexcept>
#include <string>
#include <memory>
#include <cstdio>

#if MSVC
// 음 아직 msvc 에선 안해봤다. 나중에 고치자.
typedef __int8  uint8_t;
typedef __int16 uint16_t;
typedef __int32 uint32_t;
#endif


// 뭔가를 읽으려고 하는데 버퍼가 부족한경우
struct insufficient_buffer_error : public std::runtime_error
{
    insufficient_buffer_error(): std::runtime_error("insufficient_buffer_error") {}
};


// write_T 로 적절히 버퍼를 채워나가다가 작업이 끝나면 writed() 와
// writed_len() 으로 버퍼를 얻을수있다.
class buffer_writer
{
public:
    buffer_writer()
    {
    }

    inline const char* writed() const
    {
        return &(buf_.front());
    }
    inline const int writed_len() const
    {
        return buf_.size();
    }

    inline void write_uint8(uint8_t x)
    {
        buf_.push_back(x);
    }

    inline void write_uint16(uint16_t x)
    {
        x = htons(x);
        buf_.push_back(((char*)&x)[0]);
        buf_.push_back(((char*)&x)[1]);
    }

    inline void write_uint32(uint32_t x)
    {
        x = htonl(x);
        buf_.push_back(((char*)&x)[0]);
        buf_.push_back(((char*)&x)[1]);
        buf_.push_back(((char*)&x)[2]);
        buf_.push_back(((char*)&x)[3]);        
    }

    inline void write_string(int n, const char* p)
    {
        if(n<=0) return;
        buf_.push_back(*p);
        write_string(n-1, p+1);
    }
    inline void write_string(const char* p)
    {
        write_string(strlen(p), p);
    }
    inline void write_string(const std::string& s)
    {
        write_string(s.size(), s.c_str());
    }
    
private:
    std::vector<char> buf_;

    buffer_writer(const buffer_writer&);
    void operator=(const buffer_writer&);
};



// 생성시 버퍼를 받아서 그 버퍼로부터 read_T 등의 함수로 값을 읽어내는
// 놈. 만약 버퍼길이가 부족한경우엔 insufficient_buffer_error 예외가
// 떨어지게 되어있고, 리드가 가능한지 확인하기 위한 함수로 redable_T
// 함수들이 제공된다.
//
// read_T 로 신나게 읽은후엔 남은 버퍼를 remains() 와 remains_len()
// 으로 얻을수있다.
class buffer_reader
{
public:
    buffer_reader(const char* buf, int n) : buf_(buf), len_(n), idx_(0)
    {
    }

    inline int consumed() const
    {
        return idx_;
    }
    inline const char* remains() const
    {
        return buf_ + idx_;
    }
    inline int remains_len() const
    {
        return len_ - idx_;
    }
    

    inline bool readable_uint8()
    {
        return readable(1);
    }
    inline uint8_t read_uint8()
    {
        if(!readable_uint8()) throw insufficient_buffer_error();
        uint8_t x = buf_[idx_++];
        return x;
    }

    inline bool readable_uint16()
    {
        return readable(2);
    }
    inline uint16_t read_uint16()
    {
        if(!readable_uint16()) throw insufficient_buffer_error();
        uint16_t x;
        ((char*)&x)[0] = buf_[idx_++];
        ((char*)&x)[1] = buf_[idx_++];
        return ntohs(x);
    }
    
    inline bool readable_uint32()
    {
        return readable(4);
    }    
    inline uint32_t read_uint32()
    {
        if(!readable_uint32()) throw insufficient_buffer_error();
        uint32_t x;
        ((char*)&x)[0] = buf_[idx_++];
        ((char*)&x)[1] = buf_[idx_++];
        ((char*)&x)[2] = buf_[idx_++];
        ((char*)&x)[3] = buf_[idx_++];
        return ntohl(x);
    }


    inline bool readable_string(int n)
    {
        return readable(n);
    }
    inline void read_string(int n, char* buf)
    {
        if(!readable_string(n)) throw insufficient_buffer_error();
        if(n <= 0) {
            return;
        }
        buf[0] = buf_[idx_++];
        read_string(n-1, buf+1);
    }
    inline std::string read_string(int n)
    {
        std::auto_ptr<char> buf(new char(n));
        read_string(n, buf.get());
        return std::string(buf.get());
    }

private:
    const char* buf_;
    const int   len_;
    int         idx_;

    buffer_reader(const buffer_reader&);
    void operator=(const buffer_reader&);

    inline bool readable(int n)
    {
        return n <= remains_len();
    }
};



#endif

이건 간단히 돌려본것

펼쳐두기..

#include "bufrw.hpp"
#include <cassert>
#include <stdio.h>

void test_simple()
{
    buffer_writer w;
    w.write_uint8(8);
    w.write_uint16(3000);
    w.write_uint32(8000);

    buffer_reader r(w.writed(), w.writed_len());
    assert(r.read_uint8() == 8);
    assert(r.read_uint16() == 3000);
    assert(r.read_uint32() == 8000);
    assert(r.remains_len() == 0);
}

void test_pascal_string(const char* t)
{
    // 요렇게.. 16비트로 길이 적고 문자열 적은 패킷은
    buffer_writer w;
    w.write_uint16(strlen(t));
    w.write_string(t);

    // 요렇게.. 길이 읽고 그만큼 문자열 읽으면 된다.
    buffer_reader r(w.writed(), w.writed_len());
    int l = r.read_uint16();
    std::string t2 = r.read_string(l);
    assert(t2 == t);
}


int main()
{
    test_simple();
    test_pascal_string("hahahahaha damamamamdm");
}

음.. 이건 비슷한 스타일의 파이썬 코드 사실 이걸 먼저 작성했는데 C++  버전도 필요해진것.

펼쳐두기..

# -*- coding: utf-8 -*-

from struct import unpack_from

class reader:
    """ 간단한 버퍼 리더

    몇가지 타입별로
    readable_foo
    peek_foo
    pop_foo
    read_foo
    의 함수들을 제공한다.

    리딩이 끝난후 남은 버퍼를 얻기 위한 함수로
    remains
    를 제공한다.

    TODO 사실 이런 클래스를 껴넣는게 좀 부담되는데 C/C++ 이라면
    인라이닝이 잘 되니 이런 헬퍼 클래스가 어울리지만 파이썬은 인라인이
    없는것으로 기억한다... 흠 나중에 좀 껄쩍지근 하면 패킷모양이 완성된
    후에 좀더 타이트한 코드로 재작성을 하자.
    """

    
    def __init__(self, buf):
        self.buf = buf
        self.i   = 0

    # peek, pop, readable 은 다른 함수들이 불러쓰는 유틸리티 함수
    def peek(self,fmt):
        return unpack_from(fmt, self.buf, self.i)[0]
    def pop(self, x):
        self.i += x
    def readable(self, x):
        return  x <= len(self.buf) - self.i

    # pop 하고 남은 버퍼
    def remains(self):
        return self.buf[self.i:]
            
    # uint8
    def readable_uint8(self):
        return self.readable(1)
    def peek_uint8(self):
        return self.peek("B")
    def pop_uint8(self):
        self.pop(1)
    def read_uint8(self):
        x = self.peek_uint8()
        self.pop_uint8()
        return x

    # uint16 (network endian)
    def readable_uint16(self):
        return self.readable(2)
    def peek_uint16(self):
        return self.peek("!H")
    def pop_uint16(self):
        self.pop(2)
    def read_uint16(self):
        x = self.peek_uint16()
        self.pop_uint16()
        return x

    # uint32 (network endian)
    def readable_uint32(self):
        return self.readable(4)
    def peek_uint32(self):
        return self.peek("!I")
    def pop_uint32(self):
        self.pop(4)
    def read_uint32(self):
        x = self.peek_uint32()
        self.pop_uint32()
        return x

    # uint64
    # 음 이건 좀 애매해서 구현 안했다.
    # 
    # struct 문서에 의하면 Q 가 unsigned long long 타입인데 이게 해당
    # 플래폼 C 컴파일러의 long long 을 쓴다고 명시되어있다(윈도일경우엔
    # __int64 라네) 어쨌건 C 표준은 long long 이 64비트 이상 이라고만
    # 정의하고 있는것으로 아는데 그렇다면 엄밀히 말해서 Q 가
    # 64비트이상을 읽는 경우도 생길 가능성이 있다는 소리.
    #
    # 따라서 일단 비워둔다.


    # nbyte string
    def readable_string(self, n):
        return self.readable(n)
    def peek_string(self, n):
        return self.peek("%ds" % n)
    def pop_string(self, n):
        return self.pop(n)
    def read_string(self, n):
        x = self.peek_string(n)
        self.pop_string(n)
        return x

펼쳐두기..

# -*- coding: utf-8 -*-

from struct import pack

class writer:
    """ 간단한 버퍼 라이터

    몇가지 타입별로
    write_foo
    의 함수를 제공한다.

    현재까지 쓴 버퍼 얻기위한 함수로
    writed
    함수를 제공한다.


    TODO pack 을 쓰게 되면 매번 스트링 오브젝트를 생성하고 + 를 부르는
    식으로 돌아가는데 성능상 별로겠지. 미리 적절히 버퍼를 만들고
    pack_into 를 쓰게 되면 성능개선이 가능하다. 단 이경우 일반 스트링
    타입을 사용할수 없으니 좀 성가시다.
    http://coding.derkeiler.com/Archive/Python/comp.lang.python/2008-09/msg02039.html
    를 참고.
    """

    def __init__(self):
        self.buf = ""
        
    def writed(self):
        return self.buf

    # 유틸리티 함수
    def write(self, fmt, x):
        self.buf += pack(fmt, x)

    # uint8
    def write_uint8(self, x):
        self.write("B", x)
    # uint16
    def write_uint16(self, x):
        self.write("!H", x)
    # uint32
    def writer_uint32(self, x):
        self.write("!I", x)
    # n-byte string
    def write_string(self, x):
        self.write("%ds" % len(x), x)

nose, 파이썬 유닛테스팅 라이브러리

http://code.google.com/p/python-nose/
http://somethingaboutorange.com/mrl/projects/nose/0.11.1/index.html


아.. 파이썬 모듈 임포팅은 정말 어색하구먼.
패키지라는놈을 써볼라 했는데 이게 또 아주 요상해서 코드를 따로 뽑아돌리기가 쉽질 않네. 이전에는 그냥 __name__ 체크해서 테스트 함수 쭉 돌려보는 식으로 했었는데 모듈/패키지가 복잡해 지니 테스팅 라이브러리가 필요해졌다.

일단 doctest 는 제꼈고 unittest 를 써보려고 했는데 이게 좀 쓰기가 성가시더라. 병신같은 JUnit 을 그대로 따온건지(JUnit 은 잘 모르겠다만) 테스트 케이스를 만드려면 클래스를 매번 추가해야 하고 이 케이스들을 수작업으로 등록해주거나 또는 케이스 찾는 코드를 직접 작성해줘야 하더라.

뭐 결국 nose 를 쓰면서 대부분의 불편함이 해결됐다.
우왕ㅋ굳ㅋ

python sizeof

http://stackoverflow.com/questions/449560/how-do-i-determine-the-size-of-an-object-in-python

2.6 부터 생긴거라 구글링시 첫번째로 검색이 잘 안되길래 적어둔다.



돌려봤더니 이리 나오네. 빈스트링이 24 바이트(의 오버헤드)를 먹는다고 보면 되려나?

>>> import sys
>>> map(sys.getsizeof, ["", ".", "."*100])
[24, 25, 124]
>>> map(sys.getsizeof, [0,1,1000**100000])
[12, 12, 132892]
>>>

추가.
getsizeof 를 리스트(컨테이너타입) 에 적용해봤더니 엘리먼트의 사이즈는 재주지 않는것으로 보인다.

>>> sys.getsizeof([])
36
>>> sys.getsizeof([1,2,3])
48
>>> sys.getsizeof([1,2,3,4,5,6])
60
>>> sys.getsizeof([1,2,3,4,5,6,""])
64
>>> sys.getsizeof([1,2,3,4,5,6,"1"*1000000000])
64
>>>

추가.
http://www.reddit.com/r/programming/comments/9gf2b/sizes_of_common_python_objects/
읽어보자.

wubi 쓰지말자 재확인

wubi 가 내 PC 에서는 성능상의 문제가 심각해서 후회중인데...
뭐 지금은 윈도에서 작업해야할 일 때문에 윈도 + 포터블 우분투를 쓰고있는 중이지만.
어쨌건.


회사 다른 직원 PC 를 봐주고 있다가
wubi 를 통한 우분투에서 작업도중 PC 가 갑자기 먹통. 헐

뭐 좋다 다운될수도 있지.
그런데 문제는 다시 부팅후에 wubi 부팅을 고르면(wubi 이므로 이 과정은 윈도 부트로더) grub 프롬프트만 뜨고 더이상 진행이 안된다.

결론만 적자면 wubi 가 쓰던 파티션 파일이 깨졌더라!
헐 이거뭐 앞뒤인과는 모르겠다만 어쨌건 최종적으로 내가 확인한것은 윈도쪽 ntfs 가 깨졌다는거. 탐색기에서는 해당 폴더로 진입 자체가 안되고(에러메시지는 기억안나네 지금 퇴근하고 적는거라) chkdsk 도 에러진단을 내준다(역시 메시지는 기억안난다)

chkdsk /f 돌려주고 나왔는데 그뒤는 모르겠네

어쨌건 wubi 는 단순 구경용이다.
주위에서 이거 쓴다고 하면 일단 말리고 보자.

C++ 빌드툴 벤치마크

http://retropaganda.info/~bohan/work/sf/psycle/branches/bohan/wonderbuild/benchmarks/time.xml

오 이런 벤치도 있었네.
scons 는 여전히 느리군.

역시 cmake 가 문법이 병신같지만 달리 대안이 없네.
뭐 사실 속도가 좀 느려도 IDE 용 프로젝트 파일 만들어주는 기능때문에
남들하고 같이 일하려면 cmake 외엔 답이없다.



흠. waf 는 예전에 내가 빌드툴 검토할땐 없던 녀석인데 내기억이 맞으면 아마 scons 에서 갈라진 놈으로 알고있는데 음. 나중에 시간나면 boost build 최신버전이랑 같이 다시 검토좀 해봐야 겠구먼. boost build 에 파이썬 올린다던게 구현이 됐나 모르겠네.

EC2 오픈소스 클론

http://www.eucalyptus.com/

제목엔 클론이라고 적었는데 그건 내가 나중에 쉽게 읽으려고 붙인 거고 이넘들 말에 의하면 EC2 와 같은 기능을 제공하긴 하지만 내부는 다르다고 하네. (참고)

이런류(클라우드 라고들 하던데)는 아직 나한테는 필요없는거라 살펴보지는 않았다만 기억해두면 좋을것 같다. EC2 는 언젠가 한번쯤은 써보고 싶은 놈이기도 하고.

시리얼 포트 제어할때 쓸만한 바이너리 지원하는 에뮬레이터

http://realterm.sourceforge.net/

아스키만 필요하면 이맥스의 serial-term 이나 테라텀을 쓰면 되고
바이너리 패킷을 주고받아야 한다면 리얼텀을 고려해보자.


추가.
리얼텀 그다지 좋지 않다.

fork bomb

http://en.wikipedia.org/wiki/Fork_bomb

이런걸 fork bomb 이라고 하는구먼.
저기 소개된 코드중 몇개가 아주 멋지길래 적어둔다.