Database

conf.ini

@@ -0,0 +1,7 @@
+[default]
+cookiesecret = some secrete phrase
+mapohome = /mapo/root/folder
+
+[googleoauth]
+clientid = client_id
+clientsecret = client_secret

db/db.go

@@ -22,3 +22,68 @@ Package db contains a data abstraction layer and underlying facilities
 to store entities in a database.
 */
 package db
+
+import (
+    "github.com/maponet/utils/log"
+
+    "labix.org/v2/mgo"
+    "labix.org/v2/mgo/bson"
+)
+
+// un oggetto globale che contiene una connessione attiva con la database.
+var database *mgo.Database
+
+// TODO: definire una funzione che si occupa con la creazione e gestione della
+// connessione verso un database.
+func NewConnection(databaseName string) error {
+    log.Info("executing NewConnection function")
+
+    session, err := mgo.Dial("localhost")
+    if err != nil {
+        return err
+    }
+
+    database = session.DB(databaseName)
+    return nil
+    // connessione alla data base avvenne usando diversi livelli di autenticazione
+}
+
+// Store salva nella database un singolo oggetto
+func Store(data interface{}, table string) error {
+
+    c := database.C(table)
+
+    err := c.Insert(data)
+
+    return err
+}
+
+// RestoreOne riprende dalla database un singolo oggetto identificato da un id
+func RestoreOne(data interface{}, filter bson.M, table string) error {
+
+    c := database.C(table)
+
+    err := c.Find(filter).One(data)
+
+    return err
+}
+
+// RestoreList riprende dalla database una lista (tutti) di oggetti, senza alcun filtro
+func RestoreList(data interface{}, filter bson.M, table string) error {
+
+    c := database.C(table)
+
+    err := c.Find(filter).All(data)
+
+    return err
+}
+
+// Update aggiorna i valori di un oggetto nella database, identificato da un id
+func Update(data interface{}, id string, table string) error {
+
+    c := database.C(table)
+
+    err := c.Update(bson.M{"_id": id}, data)
+
+    return err
+}

mapo.go

@@ -20,32 +20,119 @@ along with Mapo.  If not, see <http://www.gnu.org/licenses/>.
 package main
 
 import (
-	"mapo/log"
+    "mapo/db"
+	"github.com/maponet/utils/log"
+	"github.com/maponet/utils/conf"
+
+	"flag"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
 )
 
 func main() {
-	// parse flags
+
+	/*
+	parse flags
+
+	In some situation we will pass path to configuration file as a command line
+	value. This meaning that for first off all we need to define and parse all flags.
+	The only flag that we required on this step is only conf flag ... But we
+	can't distribute code with same functionality along file or files.
+	*/
+	var logLevel = log.FlagLevel("log")
+	var confFilePath = flag.String("conf", "./conf.ini", "set path to configuration file")
+	flag.Parse()
 
 	// load config and setup application
-	log.SetLevel(log.DEBUG)
-	log.Info("Setting log level to DEBUG")
+	err := conf.ParseConfigFile(*confFilePath)
+	if err != nil {
+		log.Error("%v", err)
+		return
+	}
+
+	// setup configuration value passed as command line arguments
+	if len(*logLevel) > 0 {
+		conf.GlobalConfiguration.AddOption("default", "loglevel", *logLevel)
+	}
+
+	// setup application
+
+	// set log level
+	value, _ := conf.GlobalConfiguration.GetString("default", "loglevel")
+	if err := log.SetLevelString(value); err != nil {
+		log.Error("%v", err)
+		return
+	}
 
 	log.Info("Starting application")
 
-	// register with supervisor
-	log.Info("Joining supervisor")
-
 	// init db
 	log.Info("Initializing db")
+    /*
+    in questa configurazione, connessione alla database viene attivata in un
+    oggetto definito globalmente al interno del modulo db.
+    L'idea originale per Mapo è di creare un oggetto che contenga la
+    connessione attiva e passare questo aggetto a tutte le funzione che ne
+    hanno bisogno di fare una richiesta alla database.
+
+    Passare l'oggetto database da una funzione ad altra, potrebbe
+    significare, creare una catena dalla prima funzione all'ultima. Che
+    avvolte non fa niente altro che aumentare il numero dei parametri passati
+    da una funzione ad altra. Per esempio, la connessione al database si usa
+    nel modulo objectspace che viene chiamato dal modulo admin che al suo tempo
+    viene chiamato da main. Inutile passare questo oggetto al modulo admin,
+    visto che li lui non serve.
+
+    NOTA: accesso ai oggetti globali deve essere in qualche modo sincronizzato
+    per evitare i problemi di inconsistenza.
+
+    NOTA: le osservazioni dimostrano che avendo una connessione attiva alla
+    database che poi viene riutilizzata, diminuisce considerevolmente i tempi di
+    interrogazione.
+    */
+    err = db.NewConnection("mapo")
+    if err != nil {
+        log.Error("%v", err)
+        return
+    }
+
 
 	// load addons
 	log.Info("Loading addons")
 
+	// al momento del spegnimento dell'applicazione potremo trovarci con delle
+	// connessione attive dal parte del cliente. Il handler personalizzato usato
+	// qui, ci permette di dire al server di spegnersi ma prima deve aspettare
+	// che tutte le richieste siano processate e la connessione chiusa.
+	//
+	// Oltre al spegnimento sicuro il ServeMux permette di registra dei nuovi
+	// handler usando come descrizione anche il metodo http tipo GET o POST.
+	muxer := NewServeMux()
+
+	// prepare server
+	server := &http.Server{
+		Addr:    ":8081",
+		Handler: muxer,
+	}
+
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, syscall.SIGINT)
+
+	// aviamo in una nuova gorutine la funzione che ascolterà per il segnale di
+	// spegnimento del server
+	go muxer.getSignalAndClose(c)
+
 	// register handlers
 	log.Info("Registering handlers")
 
+	// register with supervisor
+	log.Info("Joining supervisor")
+
 	// start server
-	log.Info("Accepting requests")
+	log.Info("Listening for requests")
+	log.Info("close server with message: %v", server.ListenAndServe())
 
 	// inform supervisor that we are up
 
@@ -64,7 +151,6 @@ func main() {
 
 		// return result to user
 
-
 	// close on signal
 	log.Info("Closing application")
 }