Dizin bekçisi (page 2)

August 31, 2017

Dizin bekçisi

Posted by erdem
in reply to Salih Dinçer

Permalink

erdem

Posted in reply to Salih Dinçer

Permalink

Alıntı (Salih Dinçer):

Anladığım kadarıyla bunu vibe.d ve dub ile birlikte kullanıyoruz; derlemek için dub'ı nasıl kullanmalıyız?

Salih'cim açıklamalar için teşekkürler. Ben basitçe make kullanıyorum.

Daha sonradan yaptığım uygulamalar çorba olmasın diye belgeler dizininde oluşturmuştum.

$ git clone https://github.com/etcimon/libasync.git
$ cd libasync
$ dub

Sonra bu kütüphane memutils diye bir kütüphaneye gereksinim duyuyormuş

$ git clone https://github.com/etcimon/memutils
$ cd memutils
$ dub

Ben bu kütüphaneleri kullanmak için gene Belgeler klasöründe ddili diye bir klasör ve bu klasörün içinde de import ve lib dizini oluşturmuştum.

Basitçe tüm kütüphane dosyaları lib klasörünün içine kaynak dosyalar da import klasörü içine gidiyor.

$ cd Belgeler/ddili/lib/
$ ls -a
.. libasync.a libmemutils.a

Sonra gene memutils için örnek verecek olursak. Memutils kütüphanesinin source dizininde bulunan tüm kaynak klasörünü ddili --> import klasörüne kopyalıyoruz.

Make kütüğü de şu şekilde olabilir. (İsmi Makefile)
Alıntı:

KAYNAK :=
bekçi.d \

SECENEKLER=-I../../ddili/import
KUTUPHANE= -L-l:libasync.a -L-l:libmemutils.a
EKSECENEKLER=
KUTUPHANE_DIZNI=-L-L../../ddili/lib

all: bekci

bekci:$(KAYNAK)
dmd ${KAYNAK} ${SECENEKLER} ${EKSECENEKLER} ${KUTUPHANE_DIZNI} ${KUTUPHANE} -of$@

temizle clean:
rm -f *.o *.d~ *.py~ *.c~ *.pyc *.# *.d# Makefile~
find . -maxdepth 1 ! -name 'sil' -perm +100 -type f -delete

Burada kütüphane dizinlerini göreceli olarak ../../ [bulunduğum klasörün iki üstünde] şeklinde belirttim. Ama sanırım tam dizin yolu da belirtilebilir.

Ufak değişiklik olsa da programın tamamını tekrar yazıyorum.

import std.stdio: writeln;
import std.algorithm: canFind;
import std.datetime: SysTime;
import std.datetime: Clock;
import std.format: format;

import libasync;
import libasync.watcher;
import libasync.threads;

shared static ~this() { destroyAsyncThreads(); }

struct Zaman
{
   SysTime zaman;
   ubyte saniye, dakika, saat;
   this (SysTime zaman)
   {
       this.zaman = zaman;
       this.saniye = zaman.second;
       this.dakika = zaman.minute;
       this.saat = zaman.hour;
   }

   string toString()
   {
       return format("%02s:%02s:%02s", this.saat, this.dakika, this.saniye);
   }
}

struct Dosya
{
   string isim;
   Zaman[string] olay;

   this (DWChangeInfo değişiklik)
   {
       this.isim = değişiklik.path();

       string olay;

       switch (değişiklik.event)
       {
       case DWFileEvent.CREATED:
           olay = "oluşturuldu";
           break;
       case DWFileEvent.DELETED:
           olay = "silindi";
           break;
       case DWFileEvent.MODIFIED:
           olay = "değişti";
           break;
       case DWFileEvent.MOVED_FROM:
           olay = "taşındı";
           break;

       default:
           break;
       }
       auto zaman = Zaman(Clock.currTime());
       this.olay[olay] = zaman;
   }

   void olayEkle(DWChangeInfo değişiklik)
   {
       string olay;

       switch (değişiklik.event)
       {
       case DWFileEvent.CREATED:
           olay = "oluşturuldu";
           break;
       case DWFileEvent.DELETED:
           olay = "silindi";
           break;
       case DWFileEvent.MODIFIED:
           olay = "değişti";
           break;
       case DWFileEvent.MOVED_FROM:
           olay = "taşındı";
           break;

       default:
           break;
       }
       auto zaman = Zaman(Clock.currTime());
       this.olay[olay] = zaman;
   }
}

Dosya[] dosyalar;

void dizindeDeğişiklikOldu(DWChangeInfo değişiklik)
{
   if (!canFind(değişiklik.path(), "#")
       && !canFind(değişiklik.path(), "~"))
   {
       bool dosyaKayıtlı = false;
       int i = 0;

       for (; i < dosyalar.length; ++i)
       {
           if (canFind(dosyalar[i].isim, değişiklik.path()))
           {
               writeln(dosyalar[i].isim, " dosyası zaten kayıtlıymış");
               dosyaKayıtlı = true;
               break;
           }

       }

       if (dosyaKayıtlı)
       {
           writeln("Olay ekle : ", değişiklik.event);
           dosyalar[i].olayEkle(değişiklik);
       }

       else
       {
           writeln("Olay ilk kez : ", değişiklik.event);
           dosyalar ~= Dosya(değişiklik);
       }

   }

   foreach (dosya; dosyalar)
   {
       writeln (dosya);
       writeln ("Anahtar ", dosya.olay.keys);
   }

}

void main()
{
   auto olayDöngüsü = getThreadEventLoop();

   auto bekçi = new AsyncDirectoryWatcher(olayDöngüsü);

   DWChangeInfo[8] değişiklikBilgisi;

   bekçi.run(
   {
       DWChangeInfo[] değişiklikler = değişiklikBilgisi;

       uint sayaç;

       do
       {
           sayaç = bekçi.readChanges(değişiklikler);

           foreach (i; 0 .. sayaç)
           {
               dizindeDeğişiklikOldu(değişiklikler[i]);
           }
       } while (sayaç > 0);
   });

   bekçi.watchDir("ilk");

   writeln("Olay döngüsü çalışıyor. ilk dizininde bir dosya kaydedin");

   while (olayDöngüsü.loop())
       continue;

   writeln("Olay döngüsünden çıkıldı");
}

Programı derlemek için de basitçe make komutunu kullanıyoruz.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (erdem):

wikipedia Türkiye'den açılmıyor.

Büyük kayıp. Kopyalıyorum:

File - A record stored on disk, or a record synthesized on demand by a file server, which can be accessed by multiple processes. (Most operating systems)
Signal (also Asynchronous System Trap) - A system message sent from one process to another, not usually used to transfer data but instead used to remotely command the partnered process. (Most operating systems)
Socket - A data stream sent over a network interface, either to a different process on the same computer or to another computer on the network. Typically byte-oriented, sockets rarely preserve message boundaries. Data written through a socket requires formatting to preserve message boundaries. (Most operating systems)
Unix domain socket - Similar to an internet socket but all communication occurs within the kernel. Domain sockets use the file system as their address space. Processes reference a domain socket as an inode, and multiple processes can communicate with one socket (All POSIX operating systems)
Message queue - A data stream similar to a socket, but which usually preserves message boundaries. Typically implemented by the operating system, they allow multiple processes to read and write to the message queue without being directly connected to each other. (Most operating systems)
Pipe - A unidirectional data channel. Data written to the write end of the pipe is buffered by the operating system until it is read from the read end of the pipe. Two-way data streams between processes can be achieved by creating two pipes utilizing standard input and output. (All POSIX systems, Windows)
Named pipe - A pipe implemented through a file on the file system instead of standard input and output. Multiple processes can read and write to the file as a buffer for IPC data. (All POSIX systems, Windows, AmigaOS 2.0+)
Shared memory - Multiple processes are given access to the same block of memory which creates a shared buffer for the processes to communicate with each other. (All POSIX systems, Windows)
Message passing - Allows multiple programs to communicate using message queues and/or non-OS managed channels, commonly used in concurrency models. (Used in RPC, RMI, and MPI paradigms, Java RMI, CORBA, DDS, MSMQ, MailSlots, QNX, others)
Memory-mapped - file A file mapped to RAM and can be modified by changing memory addresses directly instead of outputting to a stream. This shares the same benefits as a standard file. (All POSIX systems, Windows)

Alıntı:

D için bunun pratik örneği nasıl olabilir. O zaman programın biri sunucu biri istemci gibi mi çalışacak.

Tam olarak ne düşündüğüne göre değişir. Yukarıdaki listedeki hemen herşey Phobos'ta var: file, socket, pipe, memory mapped file, vs.

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Forums