source: branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Services.Hive.Common/3.4/ServiceContracts/IHiveService.cs @ 5053

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;
using System.IO;
using HeuristicLab.Services.Hive.Common.DataTransfer;
using System.Net.Security;

namespace HeuristicLab.Services.Hive.Common.ServiceContracts {

  [ServiceContract(ProtectionLevel = ProtectionLevel.EncryptAndSign)]
  public interface IHiveService {

    #region Job Methods
    [OperationContract]
    Guid AddJob(Job job, JobData jobData);

    [OperationContract]
    Guid AddChildJob(Guid parentJobId, Job job, JobData jobData);

    [OperationContract] // formerly GetJobById
    Job GetJob(Guid jobId);

    [OperationContract] // formerly GetAllJobs
    IEnumerable<Job> GetJobs();

    [OperationContract] // formerly GetJobResults
    IEnumerable<LightweightJob> GetLightweightJobs(IEnumerable<Guid> jobIds);

    [OperationContract] // formerly GetChildJobResults
    IEnumerable<LightweightJob> GetLightweightChildJobs(Guid? parentJobId, bool recursive, bool includeParent);

    [OperationContract] // formerly GetLastSerializedResult
    JobData GetJobData(Guid jobId);

    //[OperationContract]
    //Stream GetJobDataStreamed(Guid jobId);

    [OperationContract]
    void UpdateJob(Job jobDto, JobData jobDataDto);
        
    //[OperationContract] // formerly StoreFinishedJobResultStreamed
    //void UpdateJobDataStreamed(Stream stream);

    [OperationContract]
    void DeleteChildJobs(Guid parentJobId);

    [OperationContract] // new method: appropriate job is choosen and set to 'calculating'. the slave is responsible for requesting the jobData. Server should wait some timeout until he redistributes the job
    Job AquireJob(Guid slaveId);

    //[OperationContract] // dump?
    //Job GetJobByIdWithDetails(Guid jobId);

    //[OperationContract] dump?
    //Job AddNewJob(JobData job);

    //[OperationContract]
    //void RemoveJob(Guid jobId);

    //[OperationContract] // GetJobForCalculation (was this used?
    //Job GetJob(Guid slaveId);

    //[OperationContract] --> replaced by UpdateJob
    //void StoreFinishedJobResult(Guid slaveId, Guid jobId, byte[] result, TimeSpan executionTime, string exception);

    //[OperationContract] dump this! a slave should just check if job is still offline, if so it can submit the finished job, otherwise throw away! its a rare case that a slave reawakes with a finished job
    //void IsJobStillNeeded(Guid jobId);

    //[OperationContract] // dump?
    //Job AddJobWithGroupStrings(JobData jobObj, IEnumerable<string> groups);
    #endregion

    #region Job Control Methods
    [OperationContract]
    void StopJob(Guid jobId);

    [OperationContract]
    Job PauseJob(Guid jobId);
    #endregion

    #region HiveExperiment Methods
    [OperationContract]
    HiveExperiment GetHiveExperiment(Guid id);

    /// <summary>
    /// Returns all experiments for the current user
    /// </summary>
    [OperationContract]
    IEnumerable<HiveExperiment> GetHiveExperiments();

    [OperationContract]
    Guid AddHiveExperiment(HiveExperiment hiveExperimentDto);

    [OperationContract]
    void UpdateHiveExperiment(HiveExperiment hiveExperimentDto);

    [OperationContract]
    void DeleteHiveExperiment(Guid hiveExperimentId);
    #endregion

    #region Login Methods
    // rename "Login"-methods to "Register" or "SayHello", since its only purpose is to send Slave-Info (is Login() should not be used anymore)
    /// <summary>
    /// Method can be used to check if security credentials are valid, but it does not do anything
    /// </summary>
    /// <returns></returns>
    //[OperationContract]
    //void Login();
    ///// <summary>
    ///// This method registers the slave and marks it as online
    ///// </summary>
    //[OperationContract]
    //void Login(Slave slave);
    //[OperationContract]
    //void Logout(Guid clientId);

    [OperationContract]
    void Hello(Guid slaveId, string name, int cores, int memory);

    [OperationContract]
    void GoodBye();
    #endregion

    #region Heartbeat Methods
    [OperationContract]
    List<MessageContainer> Heartbeat(Heartbeat heartbeat);
    #endregion

    #region Plugin Methods
    [OperationContract]
    Guid AddPlugin(Plugin plugin, List<PluginData> pluginData);
    [OperationContract]
    IEnumerable<Plugin> GetPlugins();
    [OperationContract]
    IEnumerable<PluginData> GetPluginDatas(List<Guid> pluginIds);
    #endregion

    // slave should be unaware of calendar. only server decides based on calendar if slave gets jobs
    //#region Calendar Methods
    //[OperationContract]
    //IEnumerable<Appointment> GetCalendar(Guid slaveId);
    //[OperationContract]
    //void SetCalendarStatus(Guid clientId, CalendarState state);
    //[OperationContract]
    //IEnumerable<Appointment> GetUptimeCalendarForResource(Guid guid);
    //[OperationContract]
    //void SetUptimeCalendarForResource(Guid guid, IEnumerable<Appointment> appointments, bool isForced);
    //#endregion

    #region Slave Methods
    [OperationContract]
    Guid AddSlave(Slave slave);

    [OperationContract]
    Guid AddSlaveGroup(SlaveGroup slaveGroup);

    [OperationContract]
    IEnumerable<Slave> GetSlaves();
    
    [OperationContract]
    //[ServiceKnownType(typeof(Resource))] - not sure about those
    //[ServiceKnownType(typeof(Slave))]
    //[ServiceKnownType(typeof(SlaveGroup))]
    IEnumerable<SlaveGroup> GetSlaveGroups();

    [OperationContract]
    void DeleteSlaveGroup(Guid clientGroupId);

    [OperationContract]
    //[ServiceKnownType(typeof(Resource))]
    //[ServiceKnownType(typeof(Slave))]
    //[ServiceKnownType(typeof(SlaveGroup))]
    void AddResourceToGroup(Guid slaveGroupId, Resource resource);

    [OperationContract]
    void RemoveResourceFromGroup(Guid slaveGroupId, Guid resourceId);

    [OperationContract]
    void UpdateSlave(Slave slave);
    #endregion
    
  }
}