Fatih Erikli

Python İstanbul Mayıs buluşmasından notlar

lapslaps — Sat, 26 May 2012 23:06:00 +0300

Bu ay da çok hareketli ve güzel geçen bir Python İstanbul buluşmasını 20 Python severin katılımıyla gerçekleştirdik. Geçen ay olduğu gibi bu buluşmada da Hipo ofisinde toplandık. Cumartesi günümüz python severlerle burada bir kahvaltı ile başladı, muhabbet ve sunumlarla devam etti. Gerçekten cumartesi günümü çok iyi değerlendirdim diyebilirim.

Bu toplantıda 3 sunum yapıldı, sunumlardan birisini de benimdi. Sunumlar sırası ile şöyle yapıldı;

Pyİst geçmişi ve yön haritası (Metin Amiroff)
Celery ve RabbitMQ (ben)
PyPy & Just-in-time (JIT) compilation (Berker Peksağ)

Celery Sunumu
Sunumda bir AMQP protokolü implementation’ı olan RabbitMQ‘yu ve bunu message broker olarak kullanabilen Celery‘nin bize getirdiği kolaylıklardan bahsettik. Sunum için ayrıca bir de demo application hazırlama fırsatı olmuştu. Bununla birlikte bir de Onur Çelebi Connect 4 oyunu için hazırladığı algoritmanın Celery halini hazırlayıp bizlere sundu.

Celery sunumuna şuradan ulaşabilirsiniz;
http://fatiherikli.com/pyist/pyist-celery.pdf

Demo uygulamayı incelemek isterseniz de;
https://github.com/fatiherikli/downforeveryoneorjustme

Onur Çelebi’nin hazırladığı demo application’a da ulaşır ulaşmaz buraya linkini koyacağım.

PyPy sunumu
Berker Peksağ hazırladığı sunumda ise PyPy‘ın sağladıkları, PyPy alternatifleri ve development sürecini anlattı. Ayrıca PyPy’ın getirdiği avantajlardan ziyade dezavantajlarına da değindi. Hoş bir sunum olmuş gerçekten. PyPy hakında değişik bilgiler edindim. Kendisine buradan teşekkürlerimi sunuyorum :)
Sunuma aşağıdaki linkten ulaşabilirsiniz;
http://berkerpeksag.github.com/slides/pypy-101-pyist/pypy-101-pyist.pdf

Python’cuların kedi sevdası
Buluşma sadece sunumlardan ibaret değildi. Hatta sunumdan çok vakti hoş sohbet, geyik ve Nerd muhabbetiyle geçirdik :)
Bunun dışında toplantıda bütün Python’cuların gönlünü kazanan minik bir misafirimiz daha vardı. Daha doğrusu pek misafir denmez, ev sahibi demek daha doğru olur. Ona herkes hipo kedi diyor. Gerçi pek rahat durmadı ama olsun, toplantıya neşe kattı diyebiliriz. Ayrıca hipo kedi sayesinde community’deki kedi severleri de tespit etmiş olduk.

Yine bir ay sonraki toplantıyı dört gözle bekliyorum. Haziranda bir Hack Day yapılması planlanıyor. Python ile uğraşan ya da merak salan herkese kaçırmamalarını tavsiye ederim :)

PyQuery: Python ile jQuery tadında html parse edin

lapslaps — Tue, 20 Mar 2012 23:58:27 +0200

En sevdiğim kütüphanelerden bir tanesini daha sizinle paylaşmak üzereyim :)

PyQuery elinizdeki html veriyi jQuery seçicileriyle ve fonksiyonlarıyla işlemenizi sağlıyor. Aşağıdaki gibi kullanabilirsiniz;

>>> from pyquery import PyQuery 
>>> j = PyQuery(url="http://fatiherikli.com")
>>> j("title").html()
'Fatih Erikli'
>>> j("p").length 
4 
>>> j("p").eq(0).parent() 
[<div.post>]
>>> print j(".post").find("h3").html()
short bio

Kurulumu:

pip install pyquery

Dökümantasyona aşağıdaki linkten ulaşabilirsiniz;
http://packages.python.org/pyquery/api.html

Backbone.js, Django ve Tastypie üçlüsü ile bir scrum board uygulaması

lapslaps — Tue, 13 Mar 2012 22:11:00 +0200

Backbone javascript ile mvc (model-view-controller) iskeleti üzerinde genişleyebilir (scalable) uygulama geliştirmenizi sağlayan bir kütüphanedir. Underscore.js ve jQuery ile birlikte kullanılmaktadır.

Uzun zamandır backbone ile scrum board tarzı bir şey yapasım vardı. En sonunda yaptım, ve kodlarını github üzerinde açtım. Aşağıdaki linkten inceleyebilirsiniz;

http://scrumboard.herokuapp.com/

Heroku üzerinde free olarak yayınladığım için biraz yavaş olabilir. O yüzden siz en iyisi aşağıdaki gibi bilgisayarınıza kurupta çalıştırın :)

$ git clone git://github.com/fatiherikli/scrumboard.git
$ cd scrumboard
$ pip install -r requirements.txt 
$ python scrumboard/manage.py runserver

scrumboard/static/js/app dizini altındaki controllers.js, views.js ve models.js dosyalarını inceleyebilirsiniz.

Ayrıca kodlara aşağıdaki linkten ulaşabilirsiniz. Hatta hoşunuza gider ve forklarsanız geliştirmeye birlikte devam edebiliriz :)

https://github.com/fatiherikli/scrumboard

Python'da fonksiyonel programlama ve bir Internal DSL örneği

lapslaps — Wed, 29 Feb 2012 03:20:00 +0200

Fonksiyonel programlama dilleri sadece fonksiyon kullanarak program geliştirmeye olanak tanır. Ayrıca fonksiyonların istenen değeri döndürmekten başka bir görevi de olmaz. Şurada daha da açıklayıcı bir tanım bulabilirsiniz.

Python fonksiyonel bir programlama dili değildir ancak fonksiyonel programlamaya özgü bazı özellikleri desteklemektedir.

Python üzerinde fonksiyonlar birer first-class objelerdir. Bu sayede fonksiyonu istediğiniz gibi saklayabilir, başka bir fonksiyon parametresi olarak alabilir, parametreleri üzerinde oynayabilirsiniz. Python’da built-in olarak high-order functions olarak bilinen verilen fonksiyon olarak parametre alan ve olarak başka bir fonksiyon veya verdiğiniz fonksiyone özgü sonuç döndüren fonksiyonlar bulunmaktadır.

Aşağıda bir kaç tane teknik ve python’da üzerinde html kod üretebilmek için bir Internal (embedded) DSL örneği verdim.

Lambda

Lambda ile isimsiz fonksiyon (anonymous function) tanımlayabilmektesiniz. Bu size fonksiyonlarınızı çok daha kısa ve tek satırda oluşturmanıza olanak tanır.

wrap_tags = lambda x, c : '<%s>%s</%s>' % (x, c, x)
print wrap_tags('strong', 'heey')
# <strong>heey</strong>

Bu fonksiyonu aşağıdaki gibi de yazabilirdiniz. İki fonksiyonun sonucu da aynıdır. Farkı ise Lambda ile tek satırda yazabiliyor olmanız.

def wrap_tags(x, c):
    return '<%s>%s' % (x, c, x)

Closures

Closures bir fonksiyonun içinde verilen değere göre döndürülen başka fonksiyonlardır. Yukarıdaki örneğimizde wrap_tags adında fonksiyon yazdık. Bu fonksiyon bize verdiğimiz tag’a ve text’e göre html kodu yazdırıyor. fonksiyonu aşağıdaki gibi closure olarak kullanalım.

def tag_factory(tag):
    def inner(code):
        return wrap_tags(tag, code)
    return inner

Bu fonksiyonun lambda şekli;

tag_factory = lambda tag : lambda code : wrap_tags(tag,  code)

tag_factory fonksiyonumuz tag parametresi almakta ve bu taga göre wrap_tags işlemini yaptıran bir fonksiyonun döndürmekte. Bu fonksiyonu aşağıdaki gibi kullanabiliriz.

print tag_factory('html')(
        tag_factory('head')(
            tag_factory('title')('SELAAM')
        )
      )
# result is <html><head><title>SELAAM</title></head></html>

Partial

functools kütüphanesindeki bu araç ile bir fonksiyonu önceden belirlediğiniz parametrelerle çağırıp kullanabilirsiniz. Bu işlemin adı currying‘dir. Örnek olarak yukarıdaki closure örneğini partial methodu ile gerçekleştirelim.

from functools import partial
wrap_tags = lambda x, c : '<%s>%s</%s>' % (x, c, x)
HTML = partial(wrap_tags, 'html')
BODY = partial(wrap_tags, 'body')
HEAD = partial(wrap_tags, 'head')
STRONG = partial(wrap_gas, 'strong')
UL = partial(wrap_tags, 'ul')
LI = partial(wrap_tags, 'li')

print HTML(        
          BODY(
              UL(
                 LI('Selamlar')
              )
          )        
      )

Reduce

Yukarıdaki örneğimizde basitçe python üzerinde html kod üretmek için mini bir Internal DSL yazdık :) Ancak bir eksiği var. Html fonksiyonları yalnız bir adet parametre alıyor. Yani yukarıdaki örnekte iki adet ya da daha fazla liste öğesi içeren bir liste çıkaramıyoruz. Bunu reduce ile aşabiliriz.

Reduce bir dizideki elemanların tümünü tek tek belirttiğiniz fonksiyona verip tüm elemanlarla ilgili bir sonuç çıkarmanızı sağlayan araçtır. Reduce’a ilk vereceğiniz parametre iki adet parametre alan bir fonksiyon, ikincisi bir liste, üçüncüsü de sonucun başlangıç (initial) değeridir. Reduce işlemi folding olarakta bilinmektedir.

Basir bir örnek yapalım;

from operator import add
print reduce(add, range(1,10))

operator.add fonksiyonu python’daki toplama işlemidir. İki adet parametre alır ve bunları toplar. Bunu biliyoruz :) biz bu fonksiyonu reduce parametresi olarak kullanıp 1’den 10’a kadar olan sayıların toplamını aldırdık.

Şimdi DSL örneğimize geri dönelim. wrap_tags fonksiyonumuzu aşağıdaki gibi değiştirelim.

from operator import concat
wrap_tags = lambda x, *c : '<%s>%s</%s>' % (x, reduce(concat, c), x)

Çıktı aşağıdaki gibidir;

print DIV(STRONG('heey '), 'selam')
# <div><strong>heey</strong> selam</div>

operator modülündeki concat python’daki string birleştirme işleminin fonksiyonudur. Reduce üzerinde bu fonksiyonu ilk parametre, *c ile aldığımız kod listesini de ikinci parametre olarak verdik. Ve problemimiz çözüldü. Bunu string fonksiyonu olan join ile aşabilirdik ama konumuz bu değil. Maksat örnek olsun :)

Biraz daha geliştirelim. Fonksiyonuza keyword arguments olarak html tag’ının parametrelerini aldıralım. Bu işlemi yapmak için ise bir başka fonksiyonel programlama aracı olan map’i kullanacağız.

Map

İki adet parametre alır. Birinci parametre fonksiyondur. İkincisi ise listedir. Map listeki her elemanı verdiğiniz fonksiyon’dan geçirir ve size tekrar liste döndürür. Aşağıdaki örnekle daha iyi anlaşılacaktır.

print map(lambda x : x*x, range(1,10))
# [1, 4, 9, 16, 25, 36, 49, 64, 81]

Parametre olarak verdiğimiz fonksiyon verilen sayının karesini döndürmekte. Gördüğünüz üzere 1’den 10’a kadar olan sayıların karesi liste şeklinde elimizde artık. Şimdi tekrar DSL örneğimize geçelim. Html tagları için parametre örneğini yapalım. Bu işlemi lambda yerine klasik fonksiyon ile yapalım.

def parameters(**p):
    def _build_parameters(parameter):
        key, value = parameter
        return ' %s="%s"' % (key, value)
    return reduce(concat, map(_build_parameters, p.items() ) , '')

wrap_tags = lambda x, *c, **p : '<%s%s>%s</%s>' % (x, parameters(**p), reduce(concat, c), x)

Bu fonksiyonun lambda şekli ise;

parameters = lambda **p : \
             reduce(concat,
                # build parameters from dict with mapping.
                map(lambda k: ' %s="%s"' % (k[0], k[1]) , p.items() ),
                '') # empty string for reduce initial.

Artık keyword-arguments olarak html parametreleri belirtebiliyoruz;

print DIV('selamlar', id='container', style='font-size:15px')
# <div style="font-size:15px" id="container">selamlar</div>

Html tag’ının parametreleri bize keyword-arguments olarak Dictionary şeklinde gelmekte. Biz bu dictionary objesini items metoduyla (key, value) şeklinde tuple içeren bir listeye dönüştürdük. Key parametremiz, value ise parametremizin değeri. Biz listedeki parametrelerimizi html’e uygun olacak şekilde döndürüp Reduce ile düz bir string haline getirdik.

Filter

Bu işleme DSL’de ihtiyaç duymadık ancak çok kullanışlı fonksiyonlardan bir tanesidir. Map ve Reduce’deki gibi ilk parametre fonksiyon, ikincisi de liste olacak şekilde kullanmaktasınız. Fonksiyonunuz boolean (true/false) bir değer döndürmelidir. Filter işlemi verdiğiniz bu fonksiyona göre listenizde filtreleme yapacaktır. Aşağıdaki örnekle çok daha iyi anlaşılacaktır.

print filter(lambda x : x % 2 == 0, range(1,10))
# [2, 4, 6, 8]

Bir sayının 2’ye bölünüp bölümediğini kontrol eden bir fonksiyon yazdık. Ve bu fonksiyone göre sonucu False dönenleri filtreledik.

Ve son olarak DSL örneğini tam olarak vereyim. Ancak bir şey belirtmek istiyorum;

Dikkat. Ofiste denemeyin !

Aşağıdaki örneği tamamen fantazi olsun diye veriyorum :) Zira aşağıdaki gibi partial’ı partial olarak çağıran, lambda kullanıcam diye ortaya anlaşılmaz karman çorman bir kod çıkaran, yerden tasarruf olsun diye değişkenleri packing şeklinde tanımlayan bir iş arkadaşım olsa herhalde boğardım ben. Fonksiyonlar arasında hoplayıp zıplamak ne kadar eğlenceli olsa da abartmamak gerekir. pep-8’e ve diğer kod standartlara küfür niyetinde bir kod yazdık :)

# -*- coding:utf-8 -*-
from functools import partial
from operator import concat

parameters = lambda **p : \
             reduce(concat,
                # build parameters from dict with mapping.
                map(lambda k: ' %s="%s"' % (k[0].replace('_',''), k[1]) , p.items() ),
                '') # empty string for reduce initial.

wrap_tags = lambda x, *c, **p : \
            '<%s%s>%s</%s>' % (
                x, # open tags
                parameters(**p), # tag parameters
                reduce(concat, c), # content
                x)  # close tags

HTML, HEAD, TITLE, BODY, H1, UL, LI, FOOTER, DIV = map(\        
    partial(partial, wrap_tags),
    ['html', 'head', 'title', 'body', 'h1', 'ul', 'li', 'footer', 'div']
)


print HTML(
        HEAD(
            TITLE('Python üzerinde fonksiyonel programlama')
        ),
        BODY(
            H1('Fonksiyel programlama nedir ?', style="margin:0px;", id="title"),
            UL(
                LI('Lambda Calculus', _class="first"),
                LI('High-order Functions'),
                LI('Functions as First-class Objects'),
                LI('Closures'),
                LI('Currying', _class="last"),
            )
        ),
        FOOTER(
            DIV("Her hakkı saklıdır.", id="footer")
        )
     )

Evet, fonksiyonel programlama araçları sayesinde tüm kodumuzda sadece iki adet ismi olan fonksiyon tanımladık. Fonksiyonel programlama dillerindeki esneklik olmasa da python’da gayet tatlı bir şey çıkardık :)

Aşağıdaki bağlantıları da incelemenizi tavsiye ederim.

http://c2.com/cgi/wiki?FunctionalProgramming
http://en.wikipedia.org/wiki/Functional_programming
http://www.slideshare.net/adambyrtek/functional-programming-with-python-516744
http://www.slideshare.net/newmedio/introduction-to-functional-programming
http://burcudogan.com/2009/03/08/functional-programing-for-beginners/

Django'da admin üzerinde çalışırken hayatınızı kolaylaştıracak iki decorator

lapslaps — Tue, 28 Feb 2012 21:57:00 +0200

def allow_tags(func):
    """
    Bir ModelAdmin uzerinde yazdiginiz fonksiyonun html olarak cikti verebilmesini saglar.
    """
    func.allow_tags = True
    return func

def short_description(description):
    """
    ModelAdmin uzerinde yazdiginiz fonksiyonlara short_description atamasi yapar.
    """
    def wrap(func):
        func.short_description = description
        return func            
    return wrap

Şu şekilde kullanabilirsiniz;

class FooBarAdmin(admin.ModelAdmin):
    list_display = ('__unicode__', 'my_method')

    @allow_tags
    @short_description('Benim bold kolonum')
    def my_method(self, obj):
        return '<strong>selamm !</strong>'

Python konsolunda en son evaluate edilen değere ulaşmak

lapslaps — Fri, 17 Feb 2012 03:28:00 +0200

Bildiğiniz üzere Python konsolu üzerinde bir expression yazdığınızda size sonucunu döndürmekte. Eğer sonuç üzerinde bir işlem yapmak isterseniz onu bir değişkene atamanız gerekir normal şartlarda. Ama bazen işe yaramayabiliyor. Örneğin httplib kütüphanesindeki getresponse metodunu bir kere çağırmak durumundasınız.

Her neyse, python konsolunda en son evulate edilen değere _ (underscore) diyerek ulaşabilmekteyiz. Örnek;

>>> from myads.adserver.models import Advertisement
>>> Advertisement.objects.get(title='Adsense')
<Advertisement: Adsense>
>>> _
<Advertisement: Adsense>
>>> _.__class__
<class 'myads.adserver.models.Advertisement'>
>>> _.__class__
<class 'django.db.models.base.ModelBase'>
>>> _.__class__
<type 'type'>

Ayrıca IPython kullanıyorsanız aşağıdaki gibi bir kullanımlar da mümkün;

In [1]: 9 * 9
Out[1]: 81
In [2]: 9 * 9 * 9
Out[2]: 729
In [3]: 9 * 9 * 9 * 9
Out[3]: 6561
In [4]: _1 # ilk output
Out[4]: 81
In [5]: _2 # ikincisi
Out[5]: 729
In [6]: _3 # felan
Out[6]: 6561
In [7]: _oh # output history
Out[7]: {1: 81, 2: 729, 3: 6561, 4: 81, 5: 729, 6: 6561}
In[8]: __ # son output'tan onceki output
Out[8]: 6561
In[9]: _i1 # ilk girilen input'un unicode hali
Out[9]: u'9 * 9\n'
In [10]: _.__class__? # son output'un class'ının dokumantasyonu
Type:           type
Base Class:     <type 'type'>    
String Form:    <type 'unicode'>  
Namespace:      Interactive
Docstring:      bla bla bla...

Blog post’unun konusu IPython’a dönüşmeden burada keseyim.

Kolay gelsin :)

12 Şubat - Python İstanbul buluşması

lapslaps — Sun, 12 Feb 2012 21:37:00 +0200

Pyist’e ilk defa bugün katıldım. Şansıma bugün diğer buluşmalara nazaran beklenenden daha kalabalık bir toplantı olmuş. Yaklaşık 20 kişiydik. Gerçekten çok zevkli ve heyecan verici bir buluşmaydı.

Her ne kadar projeksiyon cihazı bulamasakta konuşmacı arkadaş (Taylan Pince) sunum konusunu çok başarılı bir şekilde anlattı. Sunumun konusu django ile RESTful API’ler geliştirmemizi kolaylaştıran django-tastypie idi. Bu zamana kadar REST API için piston kullanmaktaydım. Zannedersem bugünkü buluşmadan sonra tastypie kullanacağım :)

Böyle bir organizasyonu düzenlediği için başta Cihan Okyay‘a ve diğer emeği geçen herkese teşekkürlerimi sunuyorum.

Sunum dosyaları github’taki pyist organizasyonu altında yayınlanacaktır.

MongoDB database yapısı üzerinde MapReduce işlemleri

lapslaps — Sun, 12 Feb 2012 05:50:00 +0200

Bildiğiniz üzere MongoDB document-oriented bir NoSQL veritabanıdır. Verileri JSON şeklinde saklayıp, JSON şeklinde erişiyoruz. Daha doğrusu BSON (Binary JSON) şeklinde.

NoSQL database sistemleri üzerinde group, distinct gibi işlemler ilişkisel veritabanlarına (mysql, postgresql) nazaran biraz daha karmaşık. Bunun gibi sorgular fonksiyonel programlama’nın temellerinden olan MapReduce işlemi ile yapılmaktadır. MapReduce MongoDB üzerinde built-in olarak gelmektedir.

Map ve Reduce fonksiyonları

Sorgular için iki adet fonksiyon yazıyorsunuz; map ve reduce. Şimdilik MongoDB üzerinde sadece javascript ile yazılabiliyor.

Map: parametre olarak her bir dökümanı (ilişkisel veritabanlarındaki satır) alır ve key, value şeklinde dönüş yapar.
Reduce: map fonksiyonundan gelen key, value değerlerini parametre olarak alır ve verilerinizi bu fonksiyonda işlersiniz.

Bir örnek yapalım

Myadslot.com üzerinden örnek vermek istiyorum; istatistik dataları benim üşengeçliğimden dolayı MySQL database üzerinde diğer kayıtlar ile birlikte saklanmaktaydı. Bu gece vaktimi eski verileri MongoDB’ye aktarmak için data-migration yazarak geçirdim. MongoDB üzerinde saklanan datalar şu şekilde;

{
    "last_visit_date": "2012-01-26 18:05:41",
    "slot_id": 9,
    "user_agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 5_0_1 like Mac OS X) ",
    "last_visit_url": "http://dbdsgnr.appspot.com/",
    "visit_count": 2,
    "ip_address": "72.179.56.244",
    "advertisement_id": 7
}

Problem şu;

Slot istatistikleri sayfasında slota ait tüm reklamların görüntülenme sayısının toplamının alınması gerekiyor. Aslında bu data zaten slot üzerinde denormalize edilmiş durumda, maksat örnek olsun :)

Örnekte MongoDB client’i olarak pymongo kullanacağız. Veritabanına bağlanmak için şöyle bir fonksiyon kullanabiliriz;

import pymongo
def get_db(db_name="myadslot"):
    return pymongo.Connection()[db_name]

Map ve reduce fonksiyonlarımızı yazalım.

map_slots = """
function () {
    emit(this.slot_id, this.visit_count);
}
"""

Gördüğünüz üzere map edilen dökümana (row) this keyword’ü ile ulaşabilmekteyiz. slot_id’sini key, visit_count’u ise value olarak belirledik. Şimdi reduce fonksiyonumuzu yazalım.

reduce_slots = """
function (key, values) {
    var total = 0;
    for (var i in values) {
        total += values[i]
    }
    return total
}
"""

Reduce fonksiyonumuza slot_id ve visit_count parametre olarak geliyor. Biz burada slota ait tüm reklamların visit_count’unun toplamını döndürüyoruz. Python içinde javascript birazcık pis oluyor gördüğünüz üzere. Ancak MongoDB’nin sonraki versiyonlarında ek olarak başka script dilleri kullanabileceğiz. Şimdi bu fonksiyonlarımızı MongoDB üzerinde çalıştıralım.

db = get_db()
result = db["visitors"].map_reduce(map_slots, reduce_slots, "slot_stats")
for item in result.find():
    print item

Map reduce işleminden sonra bize geçici bir koleksiyon oluşturulmakta. Geçici koleksiyonumuzun adını slot_stats olarak belirledik. Bu koleksiyon üzerinden tekrar filtreleme yapabilmekteyiz ancak biz hepsini yazdırdık. İşlemin sonucu şu şekilde olacaktır;

{u'_id': 4L, u'value': 17.0}
{u'_id': 5L, u'value': 335909.0}
{u'_id': 6L, u'value': 3L}
{u'_id': 9L, u'value': 3736.0}
{u'_id': 10L, u'value': 4.0}
...

Ayrıca django ile birlikte MongoDB kullanımı için aşağıdaki bağlantıları göz atmanızı tavsiye ederim.

Birazcık scaling: Python ve Django uygulamalarında asenkron işler (RabbitMQ)

lapslaps — Fri, 10 Feb 2012 01:54:00 +0200

Konuya girmeden önce; artık blog post’larım django.org.tr gezegeninde yayınlanmakta. Bu yüzden bana tumblr’ın getirtiği baştan salma yazı yazma alışkanlığımı sonlandırmak istiyorum. Başlıksız ya da içeriksiz post atmak her ne kadar güzel olsa da post’lar sadece tumblr üzerinden okunmuyor. Artık özen göstererek yazmak gerekecek :)

Distributed Computing

RabbitMQ, zaten dağıtık hesaplama (distributed computing) konusunda ünlü olan Erlang dili ile geliştirilmiş AMQP(Advanced Message Queuing Protocol) protokolü üzerinde çalışan open-source bir message broker (mesaj kuyruğu diyebiliriz) yazılımıdır. Bu ve bunun gibi message broker yazılımları sayesinde kullandığımız dilden bağımsız bir şekilde yapılması uzun süren işlemleri (hesaplamalar, email vb.) çeşitli makinalara ya da aynı makina üzerindeki birden fazla worker’a dağıtabiliriz.

Gerçek hayattan bir örnek verecek olursak; scale edilmesi gereken bir django uygulamasında request ve response arasında uzun süren işlemler ya da web ile alakası olmayan ayrı bir katmanda yapılan bir iş olmaması gerekmektedir. Misal kullanıcılara bir ya da birden fazla email göndermek, uzun süren hesaplamalar yapmak, kullanıcıya yeni bir demo site açmak gibi …

Requirements;

Erlang platformu (Linux üzerindeyken RabbitMQ kendisi yüklemekte. Eğer windows üzerinde iseniz şuradan indirip kurabilirsiniz.)
RabbitMQ Server (Windows’ta iseniz şuradan indirebilirsiniz)
Kullanacağımız programlama dili için RabbitMQ client kütüphanesi. Örneklerde python için pika kullanacağız. Diğer diller için kütüphaneler şurada.

Paket manager’ımız ile rabbitmq-server’ı yükleyelim.

apt-get install rabbitmq-server

Kurulum bittiğinde server otomatik olarak başlatılacaktır. Şimdi de python kütüphanemizi yükleyelim.

pip install pika

Bu işlem de bittikten sonra yükleyeceğimiz başka bir şey kalmıyor. Örneklere geçebiliriz.

Bir mesaj kuyruğu uygulamasında üç temel yapı vardır; Consumer, Queue ve Publisher.

Consumer

Publisher’dan gelecek olan mesajlar için sürekli dinlemede olan bir nevi sunucudur. Aynı anda birden fazla consumer çalıştırabilirsiniz. RabbitMQ tüm consumer’lara eşit miktarda iş yükü dağıtmaya çalışacaktır.

Queue

Task yani görevlerin saklandığı kuyruktur. Eğer tek consumer var ise bu yapı FIFO (First in First out) yani -ilk giren ilk çıkar- şeklindedir. Zira birden fazla consumer olduğunda RabbitMQ işleri dağıtmaktadır.

Publisher

Consumer’a işleri gönderen uygulamadır. Bu bir django application’ı olabilir.

Şimdi örneğimize geçelim; peş peşe email gönderen bir uygulama simüle edelim. İlk olarak receiver yani consumer uygulamamızı yazalım.

consumer.py içeriği;

import pika, time

def callback(ch, method, properties, body):
    print "email gonderiliyor; ", body
    time.sleep(1) # gercekci olsun diye 1 saniye bekletiyoruz :)
    print "email gonderildi."

def main():
    connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
    channel = connection.channel()
    channel.queue_declare(queue='mailing')
    channel.basic_consume(callback, queue='mailing', no_ack=True)
    channel.start_consuming()

if __name__ == "__main__":
    main()

Örnekte mailing adında bir kuyruk oluşturduk ve o kuyruk üzerinde consuming işlemini başlattık. Örneği çalıştırdığınızda program dinlemeye geçecektir. Bir mesaj geldiğinde ise oluşturduğumuz callback fonksiyonu mesaj parametresi ile birlikte işlemeye başlayacaktır. Consumer uygulamamızı aşağıdaki gibi başlatalım;

python consumer.py

Şimdi ise publisher’ımızı yazalım.

publisher.py içeriği;

import sys
import pika

def main():
    connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
    channel = connection.channel()
    channel.queue_declare(queue='mailing')
    channel.basic_publish(exchange='', routing_key='mailing',body=sys.argv[1])
    connection.close()

if __name__ == "__main__":
    main()

Consumer uygulamamızdaki gibi aynı kuyruğa bağlandık ve bu sefer kuyruğa mesaj göndermesini istedik. Publisher uygulamamızı aşağıdaki gibi çalıştırdığımızda dinlemede olan consumer’ımız üzerine görevi yapacaktır.

python publisher.py fatiherikli@gmail.com

Burada önemli olan kısım publisher’dan ziyade consumer uygulamamızın yapılandırmasıdır. Örnekte biz tek bir consumer uygulaması çalıştırdık. Peş peşe publisher.py üzerinden komut göndermeye çalıştığınızda Consumer’ınız sırasıyla gönderdiğiniz komutları çalıştıracaktır.

Şimdi ise consumer.py ‘nizi farklı terminallerde aynı anda çalıştırın. Örnek olarak 3 tane consumer’ınız dinlemede olsun. Publisher’ınız üzerinden peş peşe mesaj göndermeye çalıştığınızda her consumer’da aynı görev sayısı olacak şekilde işlemlerin dağıtıldığını göreceksiniz.

Ayrıca Django ve RabbitMQ etkileşimini daha da kolaylaştıran celery projesini incelemenizi tavsiye ederim;

http://celeryproject.org/