Pokazywanie postów oznaczonych etykietą transaction. Pokaż wszystkie posty
Pokazywanie postów oznaczonych etykietą transaction. Pokaż wszystkie posty

środa, 14 października 2015

[MessageQueues] MSMQ

Mechanizm ten zintegrowany jest z systemami z rodziny Windows i Windows Server. Kolejkowanie włączamy jako feature Windowsa. Przykładowo na Win 10:

Kolejki możemy zakładać konfigurować i podglądać po przejściu do ekranu zarządzana komputerem (PPM na Komputer i wybór Zarządzaj).


Biblioteka kliencka wbudowana w jest .NET Framework i przestrzen nazw System.Messaging, Kolejki pracują w sposób synchroniczny (FIFO). Na każdej kolejce można ustawić transakcyjność oraz persystencję (MSMQ może zapisywać wiadomości na dysku)

Kolejki mogą być prywatne lub publiczne. Główna różnica polega na tym, że w przypadku publicznych kolejkek, możemy je zintegrować z Active Directory i mechanizmami security Windowsa.

Kolejki prywatne mogą być adresowane na dwa sposoby:
PATH:
- {machine}\private$\{queueName}, np:  .\private$\myqueue

DIRECT:
- DIRECT={protocol}:{address}\private$\{queueName}, np: DIRECT=TCP:192.168.2.140\private$\myqueue

Po założeniu kolejki możemy do niej wstawiać elementy w następujący sposób:

[HttpPost]
public ActionResult SendMessage(MessageEntity entity)
{
    string address = entity.UseTransaction ? ".\\private$\\transactionalcontactmessages" : ".\\private$\\contactmessages";
    using (var queue = new MessageQueue(address))
    {
        var message = new Message(new ContactMessage() { Content = entity.Content });
        message.Recoverable = entity.StoreOnDisk;

        if (entity.UseTransaction)
        {
            using (var transaction = new MessageQueueTransaction())
            {
                transaction.Begin();
                queue.Send(message, transaction);
                queue.Send(new Message("anotherMsg"), transaction);
                transaction.Commit();
            }
        }
        else
        {
            queue.Send(message);
        }
    }
    return new RedirectResult("/");
}

Transakcyjność ustawiamy w momencie zakładania kolejki. Wiadomości serializowane są do XML-a jako typ danych lub obiekt. Można wstawiać je także w dowolnym innym formacie, np. JSON ustawiając Stream na propercji Body. Wiadomości bez właściwości Recoverable zapisywane będą około 10 razy szybciej. Transakcja jest kolejnym narzutem czasowym przy zapisie, ale można dzięki niej wstawiać jednokrotnie wiele wiadomości.

Najprostszy kod przetwarzający może wyglądać w następujący sposób:

using (var queue = new MessageQueue(".\\private$\\contactmessages"))
{
    while (true)
    {
        var message = queue.Receive();
        Console.WriteLine("Processing");
    }
}

Podobnie można objąć całą operację w MessageQueueTransaction.

Request - Response

Zgodnie z tym wzorcem tworzone są dwie kolejki. Jedna strona komunikacji wstawia do pierwszej kolejki wiadomości, ustawiając property ResponseQueue. Dzięki temu, druga strona po przetworzeniu wiadomości wstawia odpowiedź do podanej kolejki. Dla każdej wiadomości można tworzyć nową kolejkę odpowiedzi.

private void RequestResponse(string queueAddress, string content)
{
    var responseQueue = MessageQueue.Create(GetPrivateQueueAddress());
    using (var queue = new MessageQueue(queueAddress))
    {
        var message = new Message(new ContactMessage() { Content = content });
        message.ResponseQueue = responseQueue;
        queue.Send(message);

        //Waiting for message
        var response = responseQueue.Receive();
    }
}

private string GetPrivateQueueAddress()
{
    return string.Format(".\\private$\\{0}", Guid.NewGuid().ToString().Substring(0, 6));
}


Kod po drugiej stronie może wyglądać w następujący sposób:

while (true)
{
    var message = queue.Receive();
    if(message.ResponseQueue != null)
    {
        using(var responseQueue = message.ResponseQueue)
        {
            var msg = new Message();
            msg.Label = "Processed";
            responseQueue.Send(msg);
        }                        
    }

    Console.WriteLine("Processing");
}

Kolejki mogą także działać w modelu Publish-Subscribe. Ich adres ustawiamy wtedy na wirtualny IP, na którym nasłuchują odbiorcy. Przykładowy adres takiej kolejki to: "FormatName:MULTICAST=234.1.1.2:8001". Wszyscy subskrybenci muszą mieć ustawione taką wartość w property MulticastAddress.

poniedziałek, 10 marca 2014

[NoSQL] Redis: klient C#

Twórcy Redis-a nie dostarczają oficjalnych sterowników do C#, ale protokół komunikacji z bazą jest na tyle prosty, że mamy do wyboru kilka driverów Redisa dla C# jak i dla wielu innych języków. W tym poście przedstawione zostaną możliwości klienta będącego częścią frameworka ServiceStack. Driver instalujemy tradycyjnie NuGetem.



Najważniejszą klasą jest RedisClient implementująca kilka ważnych interfejsów. Poza IDisposable są to:
  • IRedisNativeClient - odpowiadający natywnemu API Redis-a
  • ICacheClient - wprowadza warstwę abstrakcji dla cache'y, wykorzystywany wewnątrz ServiceStacka
  • IRedisClient  - wyższy poziom abstrakcji
  • IRedisTypedClient - operacje na typach, dodatkowe funkcjonalności
Przykłady:

using (IRedisNativeClient client = new RedisClient())
{
    client.Set("urn:messages:1", Encoding.UTF8.GetBytes("Hello C# World"));
}

using (IRedisNativeClient client = new RedisClient())
{
    var result = Encoding.UTF8.GetString(client.Get("urn:messages:1"));
    Console.WriteLine(result);
}

using (IRedisClient client = new RedisClient())
{
    var customerNames = client.Lists["urn:customernames"];
    customerNames.Clear();
    customerNames.Add("Joe");
    customerNames.Add("Mary");
    customerNames.Add("Bob");
}

using (IRedisClient client = new RedisClient())
{
    var customerNames = client.Lists["urn:customernames"];
    foreach (var name in customerNames)
        Console.WriteLine(name);
}

Typowany klient daje możliwość tworzenia sekwencji zapewniających unikatowość identyfikatorów. Sekwencje takie tworzone są "per typ".

long lastId = 0;
using(IRedisClient client = new RedisClient())
{
    var customerClient = client.GetTypedClient<Customer>();
    var customer = new Customer()
                       {
                           Id = customerClient.GetNextSequence(),
                           Address = "123 Main Street",
                           Name = "Bob Green",
                           Orders =
                               new List<Order>()
                                   {
                                       new Order() {OrderNumber = "AB123"},
                                       new Order() {OrderNumber = "AB124"}
                                   }
                       };
    var storedCustomer = customerClient.Store(customer);
    lastId = storedCustomer.Id;
}

using(IRedisClient client = new RedisClient())
{
    var customerClient = client.GetTypedClient<Customer>();
    var customer = customerClient.GetById(lastId);
    Console.WriteLine("Got customer {0} with name {1}", customer.Id, customer.Name);
}

Klient C# udostępnia też możliwość definiowania transakcji w poniższy sposób:


using(IRedisClient client = new RedisClient())
{
  var transaction = client.CreateTransaction();
  transaction.QueueCommand(c => c.Set("abc",1));
  transaction.QueueCommand(c => c.Increment("abc",1));
  transaction.Commit();
  var result = client.Get<int>("abc");
  Console.WriteLine(result);
}

poniedziałek, 3 marca 2014

[NoSQL] Redis: Typy danych, funkcjonalności

Redis wspiera 5 typów danych:

1. STRING


Podstawowy typ danych, który może reprezentować całe obiekty zserializowane do stringów,  może też być liczbą.

Podstawowe operacje na stringach:

redis 127.0.0.1:6379> set user:1 "{'name': 'Joe', 'email': 'joe@joe.com'}"
OK
redis 127.0.0.1:6379> get user:1
"{'name': 'Joe', 'email': 'joe@joe.com'}"
redis 127.0.0.1:6379> set user:id 1
OK
redis 127.0.0.1:6379> incr user:id
(integer) 2
redis 127.0.0.1:6379> append user:1 " extra data"
(integer) 50
redis 127.0.0.1:6379> get user:1
"{'name': 'Joe', 'email': 'joe@joe.com'} extra data"
redis 127.0.0.1:6379> getrange user:1 5 9
"e': '"
redis 127.0.0.1:6379> mset order:1 "o1 data" order:2 "o2 data"
OK
redis 127.0.0.1:6379> mget order:1 order:2
1) "o1 data"
2) "o2 data"
redis 127.0.0.1:6379> strlen user:1
(integer) 50

Operacje set i get służą do wstawiania / pobierania wartości pod podany klucz. Podobnie można wykorzystać operacje mset i mget, do których można podać wiele par klucz - wartość i wstawić je do bazy w obrębie jednej operacji. Wartości, które Redis rozpozna jako numeryczne, można inkrementować operacją incr. Kolejne operacje dotyczące typowo ciągów znaków to: append - doklejanie stringa na koniec wartości znajdującej się pod podanym kluczem, getrange - pobranie podzbioru znaków spod podanego klucza oraz strlen, czyli operacja zwracająca długość stringa znajdującego się pod podaną wartością. 

2. LISTA


Zbiór danych posortowanych po kolejności, w jakiej zostały dodane. Podstawowe operacje na listach:


redis 127.0.0.1:6379> lpush mylist "a"
(integer) 1
redis 127.0.0.1:6379> lpush mylist "b"
(integer) 2
redis 127.0.0.1:6379> lpush mylist "c"
(integer) 3
redis 127.0.0.1:6379> lrange mylist 0 2
1) "c"
2) "b"
3) "a"
redis 127.0.0.1:6379> ltrim mylist 0 1
OK
redis 127.0.0.1:6379> lrange mylist 0 2
1) "c"
2) "b"
redis 127.0.0.1:6379> lindex mylist 1
"b"
redis 127.0.0.1:6379> lindex mylist 0
"c"
redis 127.0.0.1:6379> lpop mylist
"c"
redis 127.0.0.1:6379> lrange mylist 0 2
1) "b"
redis 127.0.0.1:6379> rpush mylist "e"
(integer) 2
redis 127.0.0.1:6379> lrange mylist 0 2
1) "b"
2) "e"

Dane dodajemy operatorem lpush. Pobieranie odbywa się po zakresie za pomocą lrange gdzie podajemy zakres indeksów. Element spod konkretnego indeksu pobieramy przez lindex. Lista może działać jako kolejka, gdzie dodajemy dane z prawej strony (rpush) i pobieramy z lewej (lpop).

3. SET


Kolekcja unikalnych stringów. Mamy do dyspozycji operacje z teorii zbiorów. Podstawowe operacje na setach:

redis 127.0.0.1:6379> sadd names "joe" "bob" "mary"
(integer) 3
redis 127.0.0.1:6379> scard names
(integer) 3
redis 127.0.0.1:6379> smembers names
1) "bob"
2) "mary"
3) "joe"
redis 127.0.0.1:6379> sadd names2 "joe" "tim" "mary"
(integer) 3
redis 127.0.0.1:6379> sdiff names names2
1) "bob"
redis 127.0.0.1:6379> sinter names names2
1) "mary"
2) "joe"

Elementy do zbioru dodajemy za pomocą operatora sadd. Liczność zbioru możemy podejrzeć za pomocą scard, a jego elementy pobieramy przez smembers. Przykładowe operacje na zbiorach to różnica (sdiff) i przecięcie (sinter).

4. HASH


Typ danych mapujący stringowe pola na stringowe wartości. Redis jest zoptymalizowany pod kątem hashy z niewielką liczbą wartości.

redis 127.0.0.1:6379> hset user:1:h name "joe"
(integer) 1
redis 127.0.0.1:6379> hset user:1:h email "joe@joe.com"
(integer) 1
redis 127.0.0.1:6379> hgetall user:1:h
1) "name"
2) "joe"
3) "email"
4) "joe@joe.com"
redis 127.0.0.1:6379> hmget user:1:h name email
1) "joe"
2) "joe@joe.com"
redis 127.0.0.1:6379> hkeys user:1:h
1) "name"
2) "email"
redis 127.0.0.1:6379> hvals user:1:h
1) "joe"
2) "joe@joe.com"

Dane do hasha o nazwie user:1:h  pod pole name wstawiamy poleceniem hset. Wartości możemy pobrać na kilka sposobów. Jawnie podając pola (hmget), pobierając wszystkie (hvals). Same nazwy pól pobieramy poleceniem hkeys, a klucze i wartości komendą hgetall.

5. SORTED SET


Zbiory unikalnych danych posortowane po rankingu.

redis 127.0.0.1:6379> zadd hs 120 "joe" 100 "bob" 100 "mary" 90 "tim"
(integer) 4
redis 127.0.0.1:6379> zrank hs "bob"
(integer) 1

Dodajemy dane jako pary ranking - klucz poleceniem zadd, natomiast ranking konkretnego klucza (indeks) pobieramy za pomocą zrank.

Pozostałe funkcjonalności:


Redis może pracować jako message bus poprzez proste subskrybowanie / publikowanie wiadomości.

subscribe greetings //klient 1
publish greetings "hello redis" //klient 2
psubscribe greet* // subskrybuje na wszystkie kanały spełniające pattern
unsubscribe / punsubscribe

Ciekawą funkcjonalnością niekoniecznie spotykaną w bazach NoSQL jest zaimplementowana transakcyjność. Transakcję otwieramy poleceniem multi, po którym podajemy operacje mające się wykonać w obrębie transakcji. Kończymy poleceniem exec.
Z poziomu aplikacji klienckiej możemy także włączyć tryb monitorowania operacji, jakie wykonywane są na bazie poleceniem monitor. 

Redis przechowuje dane w pamięci z opcją "persisted to disk". Klient komunikuje się z serwerem po TCP wykorzystując specjalny protokół Redis-a. Baza domyślnie robi snapshoty danych na dysk co określoną liczbę zmian wartości. Plik redis.conf przechowuje konfigurację w sposób tekstowy. Można tam ustawić, co ile sekund lub ile zmian kluczy ma się robić snapshot. Przykładowo:

save 300 10 (co najmniej 300 sekund i 10 zmian kluczy)

Replikacja: działa na zasadzie master / slave(s) - slave'y pozostają domyślnie w trybie read only.

Prosta autentykacja polega na tym, że klient podaje hasło, które jest ustawione w pliku redis.conf na serwerze.

czwartek, 28 marca 2013

[HTML|JS|CSS] HTML5: WebSQL

WebSQL jest jedną z tych funkcjonalności, które pomimo iż kojarzone są ze standardem HTML5, nie znajdą się w tym standardzie. Mimo wszystko wiele przeglądarek wspiera możliwość składowania danych w relacyjnej bazie po stronie klienta. API dostępne z JavaScript pozwala na pisanie zapytań w języku SQL, a dane składowane są w pliku (podobnie jak w SQLite). Jeżeli chodzi o kompatybilność z nowoczesnymi przeglądarkami, to problem pojawia się w przypadku Firefoxa i Explorera, co wyklucza sporą część użytkowników (link).

Aby połączyć się z bazą wykorzystujemy funkcję openDatabase:

var db = openDatabase('mydb', '1.0', 'my first database', 2 * 1024 * 1024);

Jeżeli baza nie istnieje to zostaje automatycznie utworzona. Instrukcje SQL wykonywane są w funkcjach zapewniających tranzakcyjność (jeżeli którekolwiek z zapytań się nie powiedzie, cała operacja zostanie cofnięta).

$("#create").click(function(){
 db.transaction(function (tx) {
  tx.executeSql('CREATE TABLE messages (id unique, text)');
 });
});

Tranzakcje można zagnieżdżać, gdyż w callbackach odczytujemy wyniki zapytań.

$("#store").click(function(){
 var value = $("#msg").val();
 db.transaction(function (tx) {
  tx.executeSql('SELECT * FROM "messages"', [], function(tx,results){
   var i = results.rows.length + 1;
   tx.executeSql('INSERT INTO messages (id, text) VALUES (?,?)',
    [i, value]);
  });
 });
 $("#msg").val("");
});

Dane, które chcemy wyświetlić, można filtrować zgodnie ze składnią SQL.

$("#restore2").click(function(){
 var items = $("#items");
 items.html("");
 db.transaction(function (tx) {
  tx.executeSql('SELECT * FROM "messages" WHERE LENGTH(text) > 5', 
   [], function(tx,results){
   var l = results.rows.length;
   for (var i = 0; i < l; i++) {
    var item = results.rows.item(i);
    var li = $("<li>");
    $(li).html(item.id + ", " + item.text);
    items.append(li);
   };
  });
 });
});

Usuwanie z tabeli wykonuje się oczywiście przy użyciu instrukcji DELETE.

$("#removeLast").click(function(){
 var value = $("#msg").val();
 db.transaction(function (tx) {
  tx.executeSql('SELECT * FROM "messages"', [], function(tx,results){
   var i = results.rows.length;
   var sql = 'DELETE FROM "messages" WHERE "id" = ' + i;
   tx.executeSql(sql);
  });
 });
});

Na koniec warto pamiętać, że podobnie jak w przypadku IndexedDB, możemy łatwo oglądać stan naszych tabel w przeglądarce Google Chrome.

niedziela, 24 lutego 2013

[HTML|JS|CSS] HTML5: IndexedDb

Ciekawym trendem, jaki można zaobserwować w standardzie HTML5 jest możliwość składowania coraz większej ilości danych po stronie klienta. Przestarzałe ciasteczka zastępowane są przez znacznie lepszy mechanizm localStorage. To jednak nie wszystko. Pojawia się także możliwość składowania danych w dokumentowej bazie IndexedDb. Podobnie jak w WebStorage, dane zapisywane są dla danej strony internetowej i tylko z jej poziomu mogą być odczytane. Tym razem możemy jednak składować całe obiekty JavaScriptowe, a nie tylko ciągi znaków. Co więcej, zgodnie z dokumentacją IndexedDb, pojemność takiej bazy praktycznie ograniczona jest jedynie miejscem na dysku. Same zapytania wykonywane są w sposób asynchroniczny, programista zatem musi ich wynik obsłużyć w callbackach.

Pracę z indexedDb, technologią mocno eksperymentalną, nad którą prace cały czas trwają, warto rozpocząć od  przypisania sobie dla wygody każdej z możliwych implementacji bazy do jednej zmiennej.

window.indexedDB = window.indexedDB || window.webkitIndexedDB || window.mozIndexedDB || window.msIndexedDB;

Jak widać ostatnim silnikiem przeglądarek, który nie wspiera indexedDb jest Presto, na którym tworzona była Opera (obecnie opera ma także być tworzona w oparciu o webkit, więc problem znika dla nowszych wersji).

Zapisywanie obiektów do bazy odbywa się poprzez odpowiednie callbacki.

$("#store").click(function(){
 var value = $("#msg").val();
 var request = indexedDB.open("MyDb", 1); //1
 request.onsuccess = function (evt) {
  db = request.result;
  var transaction = db.transaction("messages", "readwrite"); //2
  var objectStore = transaction.objectStore("messages"); //3                   
  var req = objectStore.add({ date: new Date().toLocaleString(), message: value });
  req.onsuccess = function (evt) {
   console.log('successfully saved');
  };
 };
 request.onerror = function (evt) {
  console.dir(evt);
 };

 request.onupgradeneeded = function (evt) {
  //...
 };
});

Ważne są trzy linie:
  1. Otwieramy bazę danych o nazwie MyDb, opcjonalnie jako drugi parametr podajemy wersję schematu bazy, do której chcemy się łączyć
  2. Pierwszy argument może być także tablicą i jest listą kontenerów, na których będzie wykonywana transakcja
  3. Żeby dodać obiekt do pojedynczego kontenera potrzebujemy obiekt typu objectStore, o nazwie messages
Powyższy kod sprawdza się pod warunkiem, że mamy już utworzoną bazę i kontener, w przeciwnym wypadku wywołana zostanie funkcja onupgradeneeded. 

request.onupgradeneeded = function (evt) {
 var objectStore = evt.currentTarget.result.createObjectStore("messages", 
                             { keyPath: "id", autoIncrement: true 
                         });

    objectStore.createIndex("date", "date", { unique: false });
    objectStore.createIndex("message", "message", { unique: false });
};

Tworzymy objectStore o nazwie messages, posiadający unikalny autoinkrementujący się identyfikator. Dodatkowo, na potrzeby wyszukiwania, można utworzyć dwa indeksy.

Odczyt danych

Podczas odczytu wykorzystuje się indeksy, zwracające wartość i wskaźnik na następny element z kolekcji.

$("#restore").click(function(){
 var request = indexedDB.open("MyDb");
 request.onsuccess = function(evt){
  var db = request.result;
  var transaction = db.transaction("messages");
  var objectStore = transaction.objectStore("messages");
  var req = objectStore.openCursor();
  req.onsuccess = function(evt){
   var cursor = evt.target.result;
   if(cursor){
    var obj = cursor.value;
    var li = $("<li>");
    li.html(obj.date + ", " + obj.message);
    items.append(li);
    cursor.continue();
   }
  }
 }
});

Usuwanie

Korzystając z unikalnych indeksów, usuwanie staje się bardzo proste.Na przykład dla elementu o indeksie 1


$("#removeFirst").click(function(){
 var request = indexedDB.open("MyDb");
 request.onsuccess = function (evt) {
  db = request.result;
  var req = db.transaction(["messages"], "readwrite")
            .objectStore("messages").delete(1);
        }
});

Na koniec warto wspomnieć o tym, jak wygodnie można oglądać stan bazy w przeglądarce Google Chrome, w zakładce Resources.