/* Distribuovany Zalohovaci system ver. 0.1.0 2001-01-05 */

module Backup {

    /* -------------------------Typy a struktury--------------------- */

    /* Maska souboru a adresaru - pouzita pro vicenasobne vybery
       Prvni verze: retezce s cestou, * jako nahrada lib. poctu znaku 
       v posledni casti cesty 
    */
    typedef string FileMask; 
    typedef sequence<FileMask> FileMaskSeq;

    /* Ulozeni data */
    // Vzhledem k Jave bude lepsi reprezentace datumu retezcem
    typedef string DateTime; // yyyyMMddHHmm napr. 200101112215
    
    struct RepeatFreq {
       short every; 
       enum Freq {Minutes, Hours, Days, Weeks, Months} unit;
    };
    
    struct FileInfo { // Informace o souboru
      string name;
      long size;
      string Sum; //MD5, CRC nebo jiny, pro porovnani  
    };

    typedef sequence<FileInfo> FileInfoSeq;
    
//    Interni implementace
//    struct Auth {
//       string name;
//    string password;
//    };
   
//    typedef sequence<Auth> AuthSeq;
    
    struct Rule {
      // Zalohovaci pravidlo - jen castecne, zverejnovat atr ?     
      string agent;
      boolean repeat;       // Opakovat zalohovani ?
      RepeatFreq frequency; // jak casto
      DateTime when;        // v jakem case 
      FileMaskSeq filelists;// co
    };
    
    typedef sequence<Rule> RuleSeq;
    
    /* ----------------------------Vyjimky--------------------------- */
    exception IDException {
    }; // Vyvolana pri chybnem session ID
    
    exception InvalidPWException {
    }; // Vyvolana pri chybnem hesle agenta
    
    exception BeyondLastException {
    }; // Pokus o ziskani prvku iter. za koncem 
    
    exception BeforeFirstException { 
    }; // Pokus o opakovane ziskani prvku iter. pred zacatkem cteni;
    
    exception FileException {
    }; // Soubor zmenen behem prenosu (?)
    
    exception TransferFailedException {
    }; // Prenos souboru pri backup/restore selhal
    
    /* Systemovy log, zaznamenavajici prubeh operaci a chyby */
    interface Logger {
      void logMessage(in string invoker, in string message);
    };
   
    // Cast prenaseneho souboru
    //typedef sequence<octet, 65536> OctetSeq;
    typedef sequence<octet> OctetSeq;
    typedef OctetSeq FileChunk;
    
    /* -------------------------Rozhrani----------------------------- */
    // Postupny prenos souboru po castech
    interface FileChunker {
       readonly attribute FileInfo fInfo;
       // Max. velikost jedne casti souboru - pro zacatek 64k
       attribute long chunksize; 
       // Ziskani dalsi casti souboru 
       FileChunk nextChunk() raises (BeyondLastException, FileException);
       // Opetovne ziskani casti souboru 
       FileChunk retryChunk() raises (BeforeFirstException);
       // Dalsi casti souboru ?
       boolean hasMoreChunks();
    };
    
    interface FileIterator { // Postupne posila nazvy souboru
       // Ziskani dalsiho souboru ze seznamu
       FileChunker nextFile() raises (BeyondLastException, FileException); 
       // Opetovne cteni souboru - pri chybe nebo jeho zmene behem prenosu ?
       FileChunker retryFile() raises (BeforeFirstException, FileException);
       // Jsou k dispozici dalsi soubory ?
       boolean hasMoreFiles();
    };
    
    interface Storable {
        // Vraci soubory podle masky 
        FileIterator sendFiles(in string sid, in FileMaskSeq fMasks) 
                raises (IDException);
        // Ziska soubory z Agenta/Storage
        FileChunker getFile(in string fileName) raises (FileException);
        // Ukonci prenosy pod session ID, dale jiz neni mozno prenaset
        void endSession(in string sid) raises (IDException); 
    };

    interface Storage;
    interface Agent : Storable {
      readonly attribute string name;
   //attribute string password;
        
   // Kontrola hesla 
      boolean checkPassword(in string password);
        // Zahaji prenosy pod session ID
        void startSession(in string pass, in string sid) 
        raises (InvalidPWException); 
        // Obnoveni souboru, bude volat receiveFiles s arg. Storage
        void restoreFiles(in Storage stor, in string sid,
                          in FileMaskSeq files, in boolean replace )
            raises (TransferFailedException);
    };

    interface Storage : Storable {
      // Vlastni zalohovani, bude volat receiveFiles
      void backupFiles(in Agent source, in string sid, 
                             in FileMaskSeq files) 
         raises (TransferFailedException);
      void expireFiles(in string AgentName, in DateTime before);
      void setRestoreInterval(in string sid, in DateTime from, in DateTime to); 
//    void setExactRestore(in string sid, in DateTime backup_time);
//    void setRestoreMethod(in boolean oldest, in boolean newest, 
//                        in DateTime prefferedFrom, in DateTime prefferedTo); 
      // oldest - true - Nejstarsi verze souboru
      // newest - true - Nejnovejsi verze souboru
      
    };

    interface Control {
       // Ridici modul - jen castecne
//     attribute RuleSeq rules;
//     attribute AuthSeq auths; //nemelo by byt dano k dispozici - pouze zapis
       // Jmeno agenta + heslo - pro zaslani pozadavku na zalohovani dat
       // jinak je volano checkpassword() agenta, pro overeni aktualnosti 
       // hesla pri vkladani a odstraneni pravidel
       
       void addRule(in Rule rul, in string password)
            raises (InvalidPWException); 
       void removeRule(in Rule rul, in string password)
            raises (InvalidPWException); 
       boolean setPassword(in string agentname, in string password) 
            raises (InvalidPWException); 
       RuleSeq getRules(in string agentname); // Pravidla konkretniho agenta
    };
};