source: trunk/sources/HeuristicLab.Services.OKB/3.3/DataService.cs @ 4375

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Data.Linq;
using System.IO;
using System.Linq;
using System.ServiceModel;
using HeuristicLab.Services.OKB.DataAccess;
using log4net;

namespace HeuristicLab.Services.OKB {

  /// <summary>
  /// Implementation of the <see cref="IDataService"/>.
  /// </summary>
  [ServiceBehavior(
    InstanceContextMode = InstanceContextMode.PerSession,
    IncludeExceptionDetailInFaults = true,
    ConcurrencyMode = ConcurrencyMode.Multiple)]
  class DataService : IDisposable, IDataService {

    private enum Mode { Request, Submit, None };

    private Mode mode = Mode.None;

    private EntityType type;
    private int id = -1;
    private MemoryStream dataStream;

    private Guid sessionID;
    private static ILog logger = LogManager.GetLogger(typeof(DataService));

    private void Log(string message, params object[] args) {
      using (log4net.ThreadContext.Stacks["NDC"].Push(sessionID.ToString())) {
        logger.Info(String.Format(message, args));
      }
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="DataService"/> class.
    /// </summary>
    public DataService() {
      sessionID = Guid.NewGuid();
      Log("Instantiating new service");
    }

    private void EnsureInit() {
      if (mode != Mode.None)
        throw new FaultException(String.Format(
          "Cannot service new request while processing another {0}-Operation", mode));
    }

    private byte[] GetData(EntityType type, int id) {
      Log("loading data", type, id);
      using (OKBDataContext okb = new OKBDataContext()) {
        switch (type) {
          case EntityType.Algorithm:
            Algorithm algorithm = okb.Algorithms.Single(a => a.Id == id);
            if (algorithm.AlgorithmData == null) {
              algorithm.AlgorithmData = new AlgorithmData() {
                AlgorithmId = algorithm.Id,
                Data = new Binary(new byte[0])
              };
              okb.SubmitChanges();
            }
            return algorithm.AlgorithmData.Data.ToArray();
            break;
          case EntityType.Problem:
            Problem problem = okb.Problems.Single(p => p.Id == id);
            if (problem.ProblemData == null) {
              problem.ProblemData = new ProblemData() {
                ProblemId = problem.Id,
                Data = new Binary(new byte[0])
              };
              okb.SubmitChanges();
            }
            return problem.ProblemData.Data.ToArray();
            break;
          default:
            throw new FaultException("Unsupported EntityType");
        }
      }
    }

    private void SetData(EntityType type, int id, byte[] data) {
      Log("saving data", type, id, data.Length);
      OKBDataContext okb = new OKBDataContext();
      switch (type) {
        case EntityType.Algorithm:
          Algorithm algorithm = okb.Algorithms.Single(a => a.Id == id);
          if (algorithm.AlgorithmData == null)
            algorithm.AlgorithmData = new AlgorithmData() {
              AlgorithmId = algorithm.Id,
              Data = new Binary(new byte[0])
            };
          algorithm.AlgorithmData.Data = new Binary(data);
          okb.SubmitChanges();
          break;
        case EntityType.Problem:
          Problem problem = okb.Problems.Single(p => p.Id == id);
          if (problem.ProblemData == null)
            problem.ProblemData = new ProblemData() {
              ProblemId = problem.Id,
              Data = new Binary(new byte[0])
            };
          problem.ProblemData.Data = new Binary(data);
          okb.SubmitChanges();
          break;
        default:
          throw new FaultException("Unsupported EntityType");
      }
      okb.Dispose();
    }

    #region IDataService Members

    /// <summary>
    /// Request the specified <see cref="Algorithm"/> or <see cref="Problem"/>.
    /// </summary>
    /// <param name="type">The entity type.</param>
    /// <param name="id">The entity id.</param>
    /// <returns>The size of the data blob.</returns>
    public int Request(EntityType type, int id) {
      Log("requesting data", type, id);
      EnsureInit();
      dataStream = new MemoryStream(GetData(type, id));
      mode = Mode.Request;
      return (int)dataStream.Length;
    }

    /// <summary>
    /// Gets the next chunk of bytes.
    /// </summary>
    /// <param name="size">The maximum number of bytes to transfer.</param>
    /// <returns>An array of bytes.</returns>
    public byte[] GetNextChunk(int size) {
      if (dataStream == null || mode != Mode.Request)
        throw new FaultException("No data has been prepared, call Request first");
      byte[] chunk = new byte[Math.Min(size, dataStream.Length - dataStream.Position)];
      dataStream.Read(chunk, 0, chunk.Length);
      return chunk;
    }

    /// <summary>
    /// Prepare submission of the specified <see cref="Algorithm"/> or <see cref="Problem"/>.
    /// </summary>
    /// <param name="type">The entity type.</param>
    /// <param name="id">The entity id.</param>
    public void Submit(EntityType type, int id) {
      Log("Submitting", type, id);
      EnsureInit();
      GetData(type, id);
      this.type = type;
      this.id = id;
      mode = Mode.Submit;
      dataStream = new MemoryStream();
    }

    /// <summary>
    /// Sets the next chunk of bytes.
    /// </summary>
    /// <param name="data">The data.</param>
    public void SetNextChunk(byte[] data) {
      dataStream.Write(data, 0, data.Length);
    }

    /// <summary>
    /// Commits the transaction in case of an upload and closes
    /// the connection.
    /// </summary>
    public void TransferDone() {
      Log("commiting transfer");
      if (mode == Mode.Submit)
        SetData(type, id, dataStream.ToArray());
      Dispose();
    }

    /// <summary>
    /// Aborts the transfer.
    /// </summary>
    public void AbortTransfer() {
      Dispose();
    }

    #endregion

    #region IDisposable Members

    /// <summary>
    /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
    /// </summary>
    public void Dispose() {
      Log("disposing");
      mode = Mode.None;
      if (dataStream != null)
        dataStream.Dispose();
    }

    #endregion
  }
}