Кратко о «ленивой» инициализации.
Предположим, что у нас имеется некий объект класса A, в процессе работы этому объекту, для его внутренних нужд, может понадобится экземпляр класса VeryBigObject, а может и не понадобится, зависит от условий и событий происходящих во время выполнения программы. Мы знаем о том, что создание и инициализация объекта VeryBigObject займет большое время, а вероятность того, что он понадобится не очень велика, поэтому вместо инициализации экземпляр VeryBigObject во время инициализации объекта класса A мы бы хотели инициализировать объект VeryBigObject непосредственно перед его использованием, вот один из способов добиться такого поведения:

class A(object):
    def __init__(self):
        self.__lazy_attr = None

    @property
    def lazy_attr(self):
        if self.__lazy_attr is None:
            self.__lazy_attr = VeryBigObject()
        return self.__lazy_attr

    def process(self):
        try:
            ...
        except SomeRareError, error:
            self.__lazy_attr.process(error)
        except AnotherRareError, error:
            self.__lazy_attr.process(error)

Декоратор.
Сегодня мне наконец-то надоело писать один и тот-же код, а именно установку и проверку значений приватных атрибутов. Немного подумав выдумал вот такой декоратор, делающий за меня надоевшие телодвижения:

def lazy(func):
    @property
    def wrapper(self):
        attr_name = '__%s' % func.__name__
        try:
            value = getattr(self, attr_name)
        except AttributeError:
            value = func(self)
            setattr(self, attr_name, value)
        return value
    return wrapper

И сразу же пример того, как выглядел бы наш класс A, если бы мы использовали декоратор lazy:

class A(object):
    @lazy
    def lazy_attr(self):
        return VeryBigObject()
    ....

Декоратор работает очень просто, он оборачивает указанный метод, в нашем случае это lazy_attr .При этом обернутый метод становится свойством (property) объекта. Далее, при первом обращении к свойству, декоратор устанавливает приватный атрибут вида «__имя_свойства», у нас это будет атрибут self.__lazy_attr. Значением которого является результат вызова обернутого метода и возвращает это значение. Обернутый нами метод lazy_attr вернет экземпляр VeryBigObject. При следующих обращениях декоратор просто берет из установленного им атрибута значение и возвращает его запросившей стороне.
Немного запутанно, но, я надеюсь, глядя на код вы разберетесь. :)

def mkrequire_type_(type, error, doc_string=''):
    @append_doc_string(doc_string)
    def _make_decorator(n=0):
        def _decorator(func):
            def _wrapper(*args, **kwargs):
                if not isinstance(args[n], type):
                    raise TypeError, 'function require %s' % error
                return func(*args, **kwargs)
            return _wrapper
        return _decorator
    return _make_decorator

Для тех, кто знает, как работают декораторы, должно быть всё понятно, для тех, кто
не знает, Максим Деркачев уже все написал :). На декоратор append_doc_string и аргумент
doc_string внимания пока не обращайте, об этом далее.
Пример использования, допустим нам нужен декоратор, который проверяет, является ли аргумент целым числом:

 require_int = mkrequire_type_(int, 'integer')

Подумаем, как мы можем документировать наш только что созданный декоратор
require_int? Мы знаем, что докстринг это по сути атрибут __doc__ и нам ни чего не мешает задать его значение руками, значит можно сделать так:

 require_int = mkrequire_type_(int, 'integer')
 require_int.__doc__ = 'require int decorator'

Но, имхо, не очень красиво, хотелось бы определять докстринг сразу, при создании
декоратора. Эту задачу как раз решает append_doc_string, код которого приведен ниже:

 def append_doc_string(doc_string):
    def _decorator(function):
        function.__doc__ = doc_string
        return function
    return _decorator

Все просто и прозрачно, этот декоратор делает все тоже самое, что мы выше делали руками, теперь создание декоратора require_int будет выглядить вот так:

 require_int = mkrequire_type_(int, 'integer', doc_string='require int decorator')

Если строка документации не нужна, то достаточно не определять аргумент doc_string.
Вот вроде и всё. Have fun. :)

locale_home_network)
Есть сеть на другой стороне ната, там мы, практически, ни чего сделать не можем. (remote_home_network).
Из locale_home_network в remote_home_network можно ходить только через нат, в обратном направлении вообще ни как.
Сеть locale_home_network имеет доступ еще к одной сети(other_network), к которой пользователи remote_home_network
доступа не имеют, но очень хотят.

Нужно:
Дать доступ к other_network пользователям из remote_home_network

Вот вроде так.)
«Белые решения», типа реального адреса для vpn-сервера и т.д., не подходят)

Ниже то, что я уже придумал.
 1. Вариант бэк-коннекта, когда не клиент просит соединения у сервера, а наоборот, сервер у клиента.
Я думаю самый простой способ, но тут нужно придумать какой-то тригер, по которому сервер будет просить соединения.
Пока остановился на irc-боте. И, пока еще, не знаю, есть ли клиенты, которые умеют ждать запроса на соединение от сервера.

 .-------------------,          .---------,
 |remote_home_network|------.---|vpnclient|
 `-------------------`      |   `---------`
                            |       |
                         1.-|       |
                            |    3.-|
                ____________|___    |
                    nat     |       |
                ------------|---    |
                            |    2. |
                       .-------, |  |
                       |irc-bot|----.
                       `-------`    |
                                    |
 .-------------------,    4.    .-------,
 |locale_home_network| -------- |  vpn  |
 `-------------------`          | server|
          |                     `-------`
          |
   .-------------,
   |other_network|
   `-------------`

    1. Зарос от клиента irc-боту, наш тригер.
    2. Срабатывает тригер, сервер просит соединения у клиента.
    3. Соединение установлено.
    4. Ну и собственно туннель, vpnclient->vpnserver->
                                locale_home_network->other_network

2. вариант, с промежуточным узлом, попозже опишу)
Предложения, идеи?

class basicObject(object):
    def __init__(self):
        print "A bugogoa"

Всё становится гораздо сложнее, когда у нас в объекте появляется ссылка на другой объект, например:

class extendedObject(object):
    def __init__(self):
        self.basicObject = basicObject()

Тут мы на приеме объекта получим InsecureJelly, я примерно догадываюсь почему, но связно объяснить сейчас не могу, может кто расскажет?
В общем встал вопрос, а что делать?
Встал ответ: а хрен его знает.
Я сел. Думать.
Хорошенько подумав решил, что нужно сериализовать self.basicObject руками и слать его уже упакованным в строку, чтоб нидаибались), родилось вот это:

from StringIO import StringIO
import pickle, zlib

class extendedObject(object):
    def setBasicObject(self, basicObject):
        s_basicObject = StringIO()
        pickle.dump(basicObject, s_basicObject)
        s_basicObject.flush()
        self.basicObject = zlib.compress(
                                s_basicObject.getvalue())

zlib.compress здесь для того, чтобы у нас StringIO объекта не оставалось, zlib.compress возвращает сжатую строку.

Ну вот вроде и всё, я не знаю, на сколько такое решение правильное и безопасное, сдается мне, что есть и более прямые пути, просто я о них еще не знаю)

Как только вкурю, как это всё работает «изнутри», то отпишусь.

- — cut here (mpd.conf) —
default:
load vpn

vpn:
new -i ng0 vpn vpn
set iface disable on-demand
set iface addrs 192.168.1.1 192.168.2.1
set iface idle 0
set iface route default
set bundle disable multilink
set bundle authname “XXXXXX”
set bundle password “YYYYYY”
set link yes acfcomp protocomp
set link disable chap pap
set link accept chap pap
# set link no pap
# set link yes chap
# If remote machine is NT you need this..
set link enable no-orig-auth
set link keep-alive 10 75
set ipcp yes vjcomp
set ipcp ranges 0.0.0.0/0 0.0.0.0/0
#
# The five lines below enable Microsoft Point-to-Point encryption
# (MPPE) using the ng_mppc(8) netgraph node type.
#
set bundle enable compression
set ccp yes mppc
set ccp yes mpp-e40
set ccp yes mpp-e128
set bundle enable crypt-reqd
set ccp yes mpp-stateless
open
- — cut here —

- — cut here (mpd.links) —
vpn:
set link type pptp
set pptp self A.B.C.D
set pptp peer X.Y.Z.W
set pptp enable originate incoming outcall
- — cut here —

XXXXXX — username
YYYYYY — password
A.B.C.D — твой IP
X.Y.Z.W — IP pptp сервера

void *(*screngine_init)(void);
screngine_init = dlsym(screngine_lib, “screngine_init”);
(*screngine_call)(void);

будет не корректным.
Существует два варианта, как справиться с этой задачей:

1. Использовать функцию dlfunc заместо dlsym.
2. Использовать union такого вида: union { void *ptr; void (*call)(void); }

Использование dlfunc конечно хороший вариант, но эта функция есть не во всех системах, например на своём домашнем debian gnu/linux я её не обнаружил, хотя на соседних freebsd 6.0 она есть, поэтому я решил использовать union-метод, посчитав его более переносимым, тем более что он не на много сложнее варианта с вызовом dlfunc:

union { void *ptr; void (*call)(void); } screngine_init;
screngine_init.ptr = dlsym(screngine_lib, “screngine_init”);
screngine_init.call(void);

По моему даже красивее, чем в первоначальном варианте. :)