First draft of demo of KL service project files.

.gitignore

+.project
+.pydevproject
+
+

Dockerfile

+# DOCKERi skript
+#   OMA TEENUSE ettevalmistamisel asenda nii käesolevas failis kui ka failis README.MD string 'kl_teenus' sobiva nimega, 
+#   näiteks sõnade loendaja 'wc' korral 'kl_wc'.
+#   Nimed 'github.com' ja 'username' tuleb asendada vastavalt kasutatavale GIT repositooriumile.
+#
+# DOCKERi paigaldamiseks ja käivitamiseks:
+#   cd /soovitud/asukoht/oma/teenuse/koodile/serveris
+#   wget https://github.com/username/kl_teenus/raw/master/Dockerfile
+#   docker build -t kl_teenus .
+#   docker run --name kl_redis --rm --restart=no redis
+#   docker run --name kl_teenus -d --link kl_redis:redis -p 3003:3003 -v /etc/wrapper/teenus/:/config kl_teenus
+#
+# DOCKERi seiskamiseks:
+#   docker kill kl_teenus
+#   docker rm kl_teenus
+#
+
+FROM    debian:jessie
+
+# Kui Debianil pole vaikimisi kaasas GCC vajalikke teeke vms, siis tuleb need ka lasta installida.
+
+RUN apt-get update && \
+    apt-get -y install curl sudo && \
+    curl -sL https://deb.nodesource.com/setup | sudo bash - && \
+    apt-get -y install python build-essential nodejs wget && \
+    apt-get -y install git && echo "Installed 2"
+
+# Tagame värskeima PIPi olemasolu
+
+RUN wget https://bootstrap.pypa.io/get-pip.py && \
+    python get-pip.py && \
+    pip install -U pip
+
+RUN npm install -g forever
+
+# Valmistame ette koodi, mida me DOCKERis kasutama hakkame. Siinkohal peaks plaanima, et mis failid kus kataloogis peaks olema
+
+RUN mkdir -p /wrapper && mkdir -p /config && mkdir -p /wrapper/files && mkdir -p /wrapper/tmp && \
+cd /wrapper && \
+git clone 'https://github.com/BitWeb/keeleliin-wrapper-service.git' . && \
+git clone 'https://gitlab.keeleressursid.ee/indrek-jentson/py_tokenizer.git' && \
+cp py_tokenizer/config_dist.js . && \
+cp py_tokenizer/tokenizer.py . && \
+npm install && \
+echo "NPM is installed"
+
+# SIIA ALLA lisa kõik installeerimise käsud, mis on vajalikud sisulist tööd tegeva tarkvara X paigaldamiseks.
+# Tarkvara X paigaldamine algab 
+
+# tokenizer.py jaoks on vajalik estnltk teek
+
+RUN pip install estnltk
+
+# Tarkvara X paigaldamine lõppeb
+
+#Expose port
+EXPOSE  3003
+
+VOLUME ["/config"]
+
+CMD /./wrapper/docker_start.sh
\ No newline at end of file

README.MD

+## Projekti käivitamise ettevalmistamine dockeriga (Linuxis)
+* NB! kl_teenus asemel kasuta alljärgnevalt oma teenuse nimetust!
+* Tee käesolevast projektist enda GIT-is kas koopia või haru.
+* Tutvu saadaoleva dokumentatsiooniga ja tee oma uue projekti failidesse vajalikud muudatused. Tavaliselt on vaja muuta faile
+  * config_dist.js
+  * Dockerfile
+  * README.MD
+* Salvesta tehtud muudatused
+  * git commit -a
+  * git push
+
+## Püüa loodud projekti paigaldada
+* Kui su serveris veel pole Dockerit, siis paigalda see: http://docs.docker.com/engine/installation/
+* KÄIVITA REDIS SERVER:
+  ```
+  $ docker run --name kl_redis -d redis
+  ```
+* Lae alla oma teenuse Dockerfile
+  * wget https://github.com/username/kl_teenus/raw/master/Dockerfile
+  * Muuda allalaetud faili vastavalt vajadusele. Näiteks muuda #Expose port parameetrit vastavalt sellele, millisel pordil hakkab loodud teenus töötama.
+* Loo dockeri Image fail (kl_teenus - Image nimi):
+  ```
+  $ docker build -t kl_teenus .
+  ```
+* Soovi korral loo teenuse seadistuste faili jaoks dockeriväline kaust:
+  ```
+  $ mkdir -p /etc/wrapper/kl_teenus
+  ```
+* Käivita loodud kl_teenus:
+  ```
+$ docker run --name kl_teenus -it -d --link kl_redis:redis -p 3000:3000 -v /etc/wrapper/kl_teenus:/config kl_teenus
+  ```
+* Muuda vajaduse korral teenuse seadistusi failis /etc/wrapper/kl_teenus/config.js
+* Soovi korral saab konteineris teha toiminguid, aga eeldatavasti ei ole vaja midagi täiendavat teha:
+  ```
+  $ docker exec -it kl_teenus bash
+  ```
+  * Konteinerist saab väljuda käsuga: Ctrl+P Ctrl+Q
+* Kui muutsid midagi, siis uuenda teenust:
+  ```
+  $ docker exec kl_teenus /src/docker_update.sh
+  ```

config_dist.js

+var config = require('./global_config/global');
+
+/*
+ *	Teenuse url ilma pordita. Kasutatakse teenuse serverisse installeerimisel teenuse urli moodustamiseks: <url>:<port>/api/v1/
+ */
+config.serverUrl = 'http://localhost';
+
+/*
+ *	Redis serveri andmed. Kui kasutatakse vaikeseadeid, siis pole vaja muuta
+ */
+//config.redis = {
+//    host: process.env.REDIS_PORT_6379_TCP_ADDR || "127.0.0.1",
+//    port: process.env.REDIS_PORT_6379_TCP_PORT || 6379
+//};
+
+/*
+ * 	Nimekiri keeleliini serverirakendustest, kuhu teenuse käivitamisel see installeeritakse.
+ */
+//config.integration = [
+//    {
+//        installUrl: 'http://keeleliin.keeleressursid.ee:3000/api/v1/service/install',
+//        apiKey: 'server-wrapper-api-key'
+//    }
+//];
+
+/*
+ *	Teenuse failide salvestamise asukohad
+ */
+//config.fs = {
+//    storagePath: '/wrapper/files',
+//    tmpPath: '/wrapper/tmp'
+//};
+
+/*
+ *	Kui teenuse töös peaks tekkima vigu ja selle kohta soovitakse veadeadet emailile saada,
+ *	siis tuleks see sisse kommenteerida ja *** väjad täita
+ */
+/* config.log4js.appenders.push({
+     "type": "logLevelFilter",
+     "level": "ERROR",
+     "appender": {
+         "type": "smtp",
+         "layout": {
+             type: 'pattern',
+             pattern: "[%d] [%x{port}-%x{pid}][%5.5p] %c - %m",
+             tokens: {
+                 pid: process.pid,
+                 port: config.port
+             }
+         },
+         "recipients": "***@***.***", //komaga eraldatult eposti aadressid
+         "sendInterval": 10, //sec
+         "transport": "SMTP",
+             "SMTP": {
+                 "host": "smtp.gmail.com",
+                 "secureConnection": false,
+                 "port": 587,
+                     "auth": {
+                         "user": "***",
+                         "pass": "***"
+                     },
+                 "debug": true
+             }
+         }
+    }
+ );
+ */
+
+config.wrapper = { //teenuse seadistus
+    id: 'kl_tokenizer', // Unikaalne lühinimi
+    title: 'Teksti sõnestaja (pipe)', //Avalik nimi
+    description: 'Koostab etteantud tekstile vastava sõnede faili PipeContent formaadis', //Kirjeldus
+    port: 3003, //port
+    class: 'inputOutputLocalCommand',    //wrapperi failinimi wrapper kaustast, mida utiliidi käivitamiseks kasutatakse
+    command: 'python tokenizer.py -i [data] -o [output]',  // utiliidi käsurea käsk
+    requestConf: { //Päringu seadistus
+        requestBodyParamsMappings: { //Päringu post parameetrid
+            isAsync: { //parameeter isAsync
+                type: config.paramTypes.SELECT, //Tüüp. Võimalikud väärtused: config.paramTypes.SELECT ja config.paramTypes.TEXT
+                options: ['0', '1'], //Võimalikud sobivad väärtused
+                value: '1', //Soovituslik vaikeväärtus
+                filter: function (value) { //parameerile rakendatav filter. Antud juhul viiaks väärtus boolean kujule
+                    return value == 1;
+                },
+                required: true, //kas mittetühi väärtus on nõutud
+                allowEmpty: false, //kas parameeter peab olema saadetud
+                validator: function (value, request) { //filtreeritud väärtuse valideerimine
+                    if( typeof value != 'boolean' ){
+                        request.setMessage('isAsync', 'Peab olema boolean');
+                        return false;
+                    }
+                    return true;
+                }
+            }
+        },
+        requestFiles: { //Päringuga saadetavad failid
+            content: { //Faili võti
+                type: 'text', //Ressursi tüübi võti
+                sizeLimit: 0, //Suuruse piirang
+                sizeUnit: 'byte',//Suuruse piirangu ühik
+                isList: false //Kas tegemist võib olla ka failide listuga
+            }
+        }
+    },
+    outputTypes: [ //teenuse väljundressursside kirjeldused
+        {
+            type: 'tok_a',   //ressursi tüüp
+            key: 'output'   //väljundressursi võti
+        }
+    ],
+    sessionMaxLifetime: 600 // sessiooni maksimaalne kestvus
+};
+
+module.exports = config;
\ No newline at end of file

tokenizer.py

+#!/usr/bin/python
+#coding: utf-8
+
+import sys, getopt
+from estnltk import Text
+import codecs
+import pkg_resources
+import datetime
+import json
+
+def json_repr(obj):
+    """   Represent instance of a class as JSON.
+        Arguments:
+            obj -- any object
+        Return:
+            String that represent JSON-encoded object.
+    """
+    def serialize(obj):
+        # Recursively walk object's hierarchy. 
+        if isinstance(obj, (bool, int, long, float, basestring)):
+            return obj
+        elif isinstance(obj, dict):
+            obj = obj.copy()
+            for key in obj:
+                obj[key] = serialize(obj[key])
+            return obj
+        elif isinstance(obj, list):
+            return [serialize(item) for item in obj]
+        elif isinstance(obj, tuple):
+            return tuple(serialize([item for item in obj]))
+        elif hasattr(obj, '__dict__'):
+            return serialize(obj.__dict__)
+        else:
+            return repr(obj) # Don't know how to handle, convert to string
+    return json.dumps(serialize(obj), ensure_ascii=False)
+
+def write_header(outfile, inputfile):
+    header = {'content':inputfile, 'coding':'utf-8', 'layer':'words',
+              'processor':'estnltk',
+              'version': pkg_resources.get_distribution("estnltk").version,
+              'time': datetime.datetime.now().isoformat(),
+              'description':'This file contains list of words with positions extracted from the content.',
+              'structure':'data:[word*:{word_index,token,start,end}]'
+              }
+    outfile.write(json_repr(header) + u'\n')
+    
+def write_mapping(outfile):
+    mapping = {'fields':[
+        {'name':'word', 'label':'', 'type':'O', 'ctx':'data'},
+        {'name':'word_index','label':'i', 'type':'N', 'ctx':'word'},
+        {'name':'token', 'label':'t', 'type':'S', 'ctx':'word'},
+        {'name':'start', 'label':'s', 'type':'N', 'ctx':'word'},
+        {'name':'end', 'label':'e', 'type':'N', 'ctx':'word'}
+        ]}
+    outfile.write(json_repr(mapping) + u'\n')
+
+def main(argv):
+    inputfile = ''
+    outputfile = ''
+    helptext = 'Usage: python tokenizer.py -i <inputfile> -o <outputfile>'
+    if len(argv) == 0:
+        print helptext
+        sys.exit()
+    try:
+        opts, args = getopt.getopt(argv,"hi:o:",["ifile=","ofile="])
+    except getopt.GetoptError:
+        print helptext
+        sys.exit(2)
+    for opt, arg in opts:
+        if opt == '-h':
+            print helptext
+            sys.exit()
+        elif opt in ("-i", "--ifile"):
+            inputfile = arg
+        elif opt in ("-o", "--ofile"):
+            outputfile = arg
+    infile = codecs.open(inputfile, "r", "utf-8")
+    outfile = codecs.open(outputfile, "w", "utf-8")
+    outfile.write('{\n')
+    outfile.write('"header":')
+    write_header(outfile, inputfile)
+    outfile.write(', "mapping":')
+    write_mapping(outfile)
+    offset = 0
+    idx = 0
+    sep = ''
+    outfile.write(', "data":[\n')
+    for line in infile:
+        doc = Text(line)
+        doc.tokenize_words()
+        tokens = doc['words']
+        last_end = 0
+        for t in tokens:
+            outfile.write(sep+'{"i":'+str(idx)+', "t":"'+t['text']+'", "s":'+str(t['start']+offset)+', "e":'+str(t['end']+offset)+'}\n')
+            idx += 1
+            last_end = t['end']
+            sep = ','
+        offset += last_end + 1
+    outfile.write(']\n}\n')
+    outfile.close()
+    infile.close()
+    
+
+if __name__ == "__main__":
+    main(sys.argv[1:])