source: branches/OaaS/HeuristicLab.Services.Optimization.Controller/Azure/DAL.cs @ 9227

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using HeuristicLab.Services.Optimization.ControllerService.Interfaces;
using Microsoft.WindowsAzure;
using Microsoft.WindowsAzure.StorageClient;
using Microsoft.WindowsAzure.ServiceRuntime;
using System.Diagnostics;
using HeuristicLab.Services.Optimization.ControllerService.Model;
using HeuristicLab.Services.Optimization.ControllerService.Parsers;

namespace HeuristicLab.Services.Optimization.ControllerService.Azure {
  public static class AzureConstants {
    public static readonly string SCENARIO_TABLE = "Scenario";
    public static readonly string SCENARIO_BLOB_CONTAINER = "scenario";
    public static readonly string EXPERIMENT_TABLE = "Experiment";
    public static readonly string EXPERIMENT_BLOB_CONTAINER = "experiment";
    public static readonly string CLOUD_SETTINGS_KEY = "Cloudia.WindowsAzure.Storage";

    
  }

  public class ScenarioDao : IScenarioDao {    
    public CloudTableClient TableClient { get; set; }

    public bool Add(ScenarioEntity entity) {
      TableServiceContext serviceContext = TableClient.GetDataServiceContext();
      TableClient.CreateTableIfNotExist(AzureConstants.SCENARIO_TABLE);
      ScenarioEntity dbEntity = (from e in serviceContext.CreateQuery<ScenarioEntity>(AzureConstants.SCENARIO_TABLE)
                               where e.RowKey == entity.RowKey
                               select e).FirstOrDefault();
      if (dbEntity != null)
        return false;

      serviceContext.AddObject(AzureConstants.SCENARIO_TABLE, entity);
      serviceContext.SaveChanges();
      return true;
    }

    public bool DeleteByName(string scenarioName) {
      TableServiceContext serviceContext = TableClient.GetDataServiceContext();
      TableClient.CreateTableIfNotExist(AzureConstants.SCENARIO_TABLE);
      ScenarioEntity entity = (from e in serviceContext.CreateQuery<ScenarioEntity>(AzureConstants.SCENARIO_TABLE)
                               where e.RowKey == scenarioName
                               select e).FirstOrDefault();
      if (entity == null)
        return false;

      serviceContext.DeleteObject(entity);
      serviceContext.SaveChangesWithRetries();
      return true;
    }

    public ScenarioEntity FindByName(string scenarioName) {
      TableServiceContext serviceContext = TableClient.GetDataServiceContext();
      TableClient.CreateTableIfNotExist(AzureConstants.SCENARIO_TABLE);
      ScenarioEntity entity = (from e in serviceContext.CreateQuery<ScenarioEntity>(AzureConstants.SCENARIO_TABLE)
                               where e.RowKey == scenarioName
                               select e).FirstOrDefault();
      return entity;
    }


    public IEnumerable<ScenarioEntity> GetAllEntities() {
      TableServiceContext serviceContext = TableClient.GetDataServiceContext();
      TableClient.CreateTableIfNotExist(AzureConstants.SCENARIO_TABLE);
      return (from e in serviceContext.CreateQuery<ScenarioEntity>(AzureConstants.SCENARIO_TABLE)
             select e).AsEnumerable();
    }
  }

  public class BlobDao : IBlobDao {
    public CloudBlobClient BlobClient { get; set; }

    public bool Add(StringEntry entry) {
      CloudBlobContainer container = BlobClient.GetContainerReference(AzureConstants.SCENARIO_BLOB_CONTAINER);
      container.CreateIfNotExist();
      var blob = container.GetBlobReference(entry.Key);
      blob.UploadText(entry.Text);
      return true;
    }

    public bool DeleteByKey(string entryKey) {
      CloudBlobContainer container = BlobClient.GetContainerReference(AzureConstants.SCENARIO_BLOB_CONTAINER);
      container.CreateIfNotExist();
      var blob = container.GetBlobReference(entryKey);
      return blob.DeleteIfExists();
    }

    public StringEntry FindByKey(string entryKey) {
      CloudBlobContainer container = BlobClient.GetContainerReference(AzureConstants.SCENARIO_BLOB_CONTAINER);
      container.CreateIfNotExist();
      var blob = container.GetBlobReference(entryKey);
      return new StringEntry() { Key = entryKey, Text = blob.DownloadText() };      
    }
  }

  internal sealed class ExperimentEntity : TableServiceEntity {
    public ExperimentEntity() {
    }

    public ExperimentEntity(string user, string experimentName, string experimentUrl) {
      PartitionKey = "ScenarioPartition";
      RowKey = user + "_" + experimentName;      
      User = user;
      ExperimentJsonUrl = experimentUrl;
    }

    public string User { get; set; }

    public string ExperimentJsonUrl { get; set; }

  }

  public class ExperimentDao : IExperimentDao {
    public CloudBlobClient BlobClient { get; set; }
    public CloudTableClient TableClient { get; set; }

    public bool Add(string username, Model.Experiment experiment) {
      if (FindByName(username, experiment.Name) != null)
        return false;

      // TODO: Save the whole experiment, not just the algorithm names!!!
      CloudBlobContainer container = BlobClient.GetContainerReference(AzureConstants.EXPERIMENT_BLOB_CONTAINER);
      container.CreateIfNotExist();
      // For now we store it as JSON element in the blob store
      // TODO: Make sure, that all required properties are part of the experiment!!
      var experimentJson = AlgorithmConverter.ConvertJson(experiment);
      Guid experimentJsonGuid = Guid.NewGuid();
      var experimentJsonId = experiment.Name + "_" + experimentJsonGuid.ToString();
      var blob = container.GetBlobReference(experimentJsonId);      
      blob.UploadText(experimentJson);

      TableServiceContext serviceContext = TableClient.GetDataServiceContext();      
      TableClient.CreateTableIfNotExist(AzureConstants.EXPERIMENT_TABLE);
      var entity = new ExperimentEntity(username, experiment.Name, blob.Uri.ToString());
      serviceContext.AddObject(AzureConstants.EXPERIMENT_TABLE, entity);
      serviceContext.SaveChangesWithRetries();
      return true;
    }

    public bool DeleteByName(string username, string experiment) {
      TableServiceContext serviceContext = TableClient.GetDataServiceContext();
      TableClient.CreateTableIfNotExist(AzureConstants.EXPERIMENT_TABLE);
      var entity = (from e in serviceContext.CreateQuery<ExperimentEntity>(AzureConstants.EXPERIMENT_TABLE)
                    where e.RowKey == (username + "_" + experiment)
                    select e).FirstOrDefault();
      
      if (entity == null)
        return false;

      if (entity.ExperimentJsonUrl != null) {
        CloudBlobContainer container = BlobClient.GetContainerReference(AzureConstants.EXPERIMENT_BLOB_CONTAINER);
        container.CreateIfNotExist();
        var blob = container.GetBlobReference(entity.ExperimentJsonUrl);
        blob.DeleteIfExists();
      }

      serviceContext.DeleteObject(entity);
      serviceContext.SaveChangesWithRetries();
      return true;
    }

    public Model.Experiment FindByName(string username, string experiment) {
      TableServiceContext serviceContext = TableClient.GetDataServiceContext();
      TableClient.CreateTableIfNotExist(AzureConstants.EXPERIMENT_TABLE);
      var entity = (from e in serviceContext.CreateQuery<ExperimentEntity>(AzureConstants.EXPERIMENT_TABLE)
                    where e.RowKey == (username + "_" + experiment)
                    select e).FirstOrDefault();
      
      if (entity == null) {
        return null;
      }

      CloudBlobContainer container = BlobClient.GetContainerReference(AzureConstants.EXPERIMENT_BLOB_CONTAINER);
      container.CreateIfNotExist();
      var blob = container.GetBlobReference(entity.ExperimentJsonUrl);
      return AlgorithmConverter.ConvertExperimentSimple(blob.DownloadText());
    }

    //private Experiment Convert(ExperimentEntity entity, string entityJson) {
    //  // TODO: Read the whole experiment, not just the names!
    //  var exp = new Experiment() { Name = entity.RowKey.Split('_')[1] };
    //  foreach (var scenarioName in entity.Algorithms.Split(','))
    //    exp.Algorithm.Add(new Algorithm() { Name = scenarioName });
    //  return exp;
    //}

    public IEnumerable<Model.Experiment> GetExperiments(string user) {
      TableServiceContext serviceContext = TableClient.GetDataServiceContext();
      TableClient.CreateTableIfNotExist(AzureConstants.EXPERIMENT_TABLE);
      var entites = (from e in serviceContext.CreateQuery<ExperimentEntity>(AzureConstants.EXPERIMENT_TABLE)
                    where e.User == user
                    select e).ToList();
      var experiments = new List<Experiment>();
      CloudBlobContainer container = BlobClient.GetContainerReference(AzureConstants.EXPERIMENT_BLOB_CONTAINER);
      container.CreateIfNotExist();
      foreach (var entity in entites) {
        var blob = container.GetBlobReference(entity.ExperimentJsonUrl);
        experiments.Add(AlgorithmConverter.ConvertExperimentSimple(blob.DownloadText()));
      }
      return experiments;
    }


    public Experiment GetExperimentByName(string username, string scenario) {
      TableServiceContext serviceContext = TableClient.GetDataServiceContext();
      TableClient.CreateTableIfNotExist(AzureConstants.EXPERIMENT_TABLE);
      var entity = (from e in serviceContext.CreateQuery<ExperimentEntity>(AzureConstants.EXPERIMENT_TABLE)
                      where e.RowKey == username + "_" + scenario
                      select e).FirstOrDefault();
      if (entity == null || entity.ExperimentJsonUrl == null) {
        return null;
      }

      CloudBlobContainer container = BlobClient.GetContainerReference(AzureConstants.EXPERIMENT_BLOB_CONTAINER);
      container.CreateIfNotExist();
      var blob = container.GetBlobReference(entity.ExperimentJsonUrl);
      var exp = AlgorithmConverter.ConvertExperimentSimple(blob.DownloadText());
      return exp;
    }
  }

  public class AzureDataAccessLayer : IDataAccessLayer {
    private IScenarioDao scenarioDao;
    private IBlobDao blobDao;
    private IExperimentDao expDao;

    private CloudStorageAccount storageAccount;

    private CloudStorageAccount StorageAccount {
      get {
        if (storageAccount == null) {
          try {
            storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting(AzureConstants.CLOUD_SETTINGS_KEY));
          }
          catch (Exception ex) {
            Trace.WriteLine(ex.Message);
            storageAccount = CloudStorageAccount.Parse("DefaultEndpointsProtocol=https;AccountName=optimizationstorage1;AccountKey=n7Leom8ZFWkof/VQ2a4aRSvwOlX+Gwr3uojQF9CFJw1osmGCV0WwaNC8s7nkZ+qteLduAgW2l75WFpbXrkvG4Q==");
          }
        }
        return storageAccount; 
      }      
    }

    public IScenarioDao ScenarioDao {
      get {
        if (scenarioDao == null) {
          scenarioDao = new ScenarioDao() { TableClient = StorageAccount.CreateCloudTableClient() };
        }
        return scenarioDao;
      }
    }

    public IBlobDao BlobDao {
      get {
        if (blobDao == null) {
          blobDao = new BlobDao() { BlobClient = StorageAccount.CreateCloudBlobClient() };
        }
        return blobDao;
      }
    }

    public IExperimentDao ExperimentDao {
      get {
        if (expDao == null) {
          expDao = new ExperimentDao() { TableClient = StorageAccount.CreateCloudTableClient(), BlobClient = StorageAccount.CreateCloudBlobClient() };
        }
        return expDao;
      }
    }
  }
}