[1132] | 1 | #region License Information
|
---|
| 2 | /* HeuristicLab
|
---|
| 3 | * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
|
---|
| 4 | *
|
---|
| 5 | * This file is part of HeuristicLab.
|
---|
| 6 | *
|
---|
| 7 | * HeuristicLab is free software: you can redistribute it and/or modify
|
---|
| 8 | * it under the terms of the GNU General Public License as published by
|
---|
| 9 | * the Free Software Foundation, either version 3 of the License, or
|
---|
| 10 | * (at your option) any later version.
|
---|
| 11 | *
|
---|
| 12 | * HeuristicLab is distributed in the hope that it will be useful,
|
---|
| 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
---|
| 15 | * GNU General Public License for more details.
|
---|
| 16 | *
|
---|
| 17 | * You should have received a copy of the GNU General Public License
|
---|
| 18 | * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
|
---|
| 19 | */
|
---|
| 20 | #endregion
|
---|
| 21 |
|
---|
| 22 | using System;
|
---|
[923] | 23 | using System.Collections.Generic;
|
---|
| 24 | using System.Linq;
|
---|
| 25 | using System.Text;
|
---|
| 26 | using System.ServiceModel;
|
---|
| 27 | using HeuristicLab.Hive.Contracts.Interfaces;
|
---|
| 28 | using HeuristicLab.Hive.Contracts;
|
---|
| 29 | using HeuristicLab.Hive.Contracts.BusinessObjects;
|
---|
| 30 | using HeuristicLab.Hive.Client.Common;
|
---|
[993] | 31 | using HeuristicLab.Hive.Client.Communication.ServerService;
|
---|
[1450] | 32 | using HeuristicLab.PluginInfrastructure;
|
---|
[1939] | 33 | using System.IO;
|
---|
| 34 | using System.Runtime.Serialization.Formatters.Binary;
|
---|
[923] | 35 |
|
---|
| 36 | namespace HeuristicLab.Hive.Client.Communication {
|
---|
[1132] | 37 | /// <summary>
|
---|
| 38 | /// WcfService class is implemented as a Singleton and works as a communication Layer with the Server
|
---|
| 39 | /// </summary>
|
---|
[923] | 40 | public class WcfService {
|
---|
| 41 | private static WcfService instance;
|
---|
[1132] | 42 | /// <summary>
|
---|
| 43 | /// Getter for the Instance of the WcfService
|
---|
| 44 | /// </summary>
|
---|
| 45 | /// <returns>the Instance of the WcfService class</returns>
|
---|
[923] | 46 | public static WcfService Instance {
|
---|
| 47 | get {
|
---|
| 48 | if (instance == null) {
|
---|
| 49 | instance = new WcfService();
|
---|
| 50 | }
|
---|
| 51 | return instance;
|
---|
| 52 | }
|
---|
| 53 | }
|
---|
| 54 |
|
---|
[932] | 55 | public DateTime ConnectedSince { get; private set; }
|
---|
| 56 | public NetworkEnum.WcfConnState ConnState { get; private set; }
|
---|
| 57 | public string ServerIP { get; private set; }
|
---|
| 58 | public int ServerPort { get; private set; }
|
---|
[923] | 59 |
|
---|
[924] | 60 | public event EventHandler ConnectionRestored;
|
---|
[1081] | 61 | public event EventHandler ServerChanged;
|
---|
| 62 | public event EventHandler Connected;
|
---|
[924] | 63 |
|
---|
[1939] | 64 | public ClientFacadeClient proxy = null;
|
---|
[923] | 65 |
|
---|
[1132] | 66 | /// <summary>
|
---|
| 67 | /// Constructor
|
---|
| 68 | /// </summary>
|
---|
[923] | 69 | private WcfService() {
|
---|
[949] | 70 | ConnState = NetworkEnum.WcfConnState.Disconnected;
|
---|
[923] | 71 | }
|
---|
[1132] | 72 |
|
---|
| 73 | /// <summary>
|
---|
| 74 | /// Connects with the Server, registers the events and fires the Connected (and quiet possibly the ConnectionRestored) Event.
|
---|
| 75 | /// </summary>
|
---|
[923] | 76 | public void Connect() {
|
---|
| 77 | try {
|
---|
[2025] | 78 | if (String.Empty.Equals(ServerIP) || ServerPort == 0) {
|
---|
| 79 | Logging.Instance.Info(this.ToString(), "No Server IP or Port set!");
|
---|
| 80 | return;
|
---|
| 81 | }
|
---|
[1939] | 82 | proxy = new ClientFacadeClient(
|
---|
| 83 | WcfSettings.GetStreamedBinding(),
|
---|
[1081] | 84 | new EndpointAddress("net.tcp://" + ServerIP + ":" + ServerPort + "/HiveServer/ClientCommunicator")
|
---|
| 85 | );
|
---|
[923] | 86 |
|
---|
| 87 | proxy.LoginCompleted += new EventHandler<LoginCompletedEventArgs>(proxy_LoginCompleted);
|
---|
[1939] | 88 | proxy.SendStreamedJobCompleted += new EventHandler<SendStreamedJobCompletedEventArgs>(proxy_SendStreamedJobCompleted);
|
---|
| 89 | proxy.StoreFinishedJobResultStreamedCompleted += new EventHandler<StoreFinishedJobResultStreamedCompletedEventArgs>(proxy_StoreFinishedJobResultStreamedCompleted);
|
---|
| 90 | proxy.ProcessSnapshotStreamedCompleted += new EventHandler<ProcessSnapshotStreamedCompletedEventArgs>(proxy_ProcessSnapshotStreamedCompleted);
|
---|
[1366] | 91 | proxy.ProcessHeartBeatCompleted += new EventHandler<ProcessHeartBeatCompletedEventArgs>(proxy_ProcessHeartBeatCompleted);
|
---|
[1082] | 92 | proxy.Open();
|
---|
| 93 |
|
---|
[932] | 94 | ConnState = NetworkEnum.WcfConnState.Connected;
|
---|
[1097] | 95 | ConnectedSince = DateTime.Now;
|
---|
| 96 |
|
---|
[1082] | 97 | if (Connected != null)
|
---|
| 98 | Connected(this, new EventArgs());
|
---|
[1340] | 99 | //Todo: This won't be hit. EVER
|
---|
[1097] | 100 | if (ConnState == NetworkEnum.WcfConnState.Failed)
|
---|
| 101 | ConnectionRestored(this, new EventArgs());
|
---|
[923] | 102 | }
|
---|
[1371] | 103 | catch (Exception ex) {
|
---|
| 104 | HandleNetworkError(ex);
|
---|
[923] | 105 | }
|
---|
| 106 | }
|
---|
| 107 |
|
---|
[1379] | 108 |
|
---|
[1132] | 109 | /// <summary>
|
---|
| 110 | /// Changes the Connectionsettings (serverIP & serverPort) and reconnects
|
---|
| 111 | /// </summary>
|
---|
| 112 | /// <param name="serverIP">current Server IP</param>
|
---|
| 113 | /// <param name="serverPort">current Server Port</param>
|
---|
[932] | 114 | public void Connect(String serverIP, int serverPort) {
|
---|
[993] | 115 | String oldIp = this.ServerIP;
|
---|
| 116 | int oldPort = this.ServerPort;
|
---|
[932] | 117 | this.ServerIP = serverIP;
|
---|
[944] | 118 | this.ServerPort = serverPort;
|
---|
[923] | 119 | Connect();
|
---|
[993] | 120 | if (oldIp != serverIP || oldPort != ServerPort)
|
---|
[1036] | 121 | if(ServerChanged != null)
|
---|
| 122 | ServerChanged(this, new EventArgs());
|
---|
[923] | 123 | }
|
---|
[2025] | 124 |
|
---|
| 125 | public void SetIPAndPort(String serverIP, int serverPort) {
|
---|
| 126 | this.ServerIP = serverIP;
|
---|
| 127 | this.ServerPort = serverPort;
|
---|
| 128 | }
|
---|
[1132] | 129 |
|
---|
| 130 | /// <summary>
|
---|
| 131 | /// Disconnects the Client from the Server
|
---|
| 132 | /// </summary>
|
---|
[932] | 133 | public void Disconnect() {
|
---|
| 134 | ConnState = NetworkEnum.WcfConnState.Disconnected;
|
---|
| 135 | }
|
---|
| 136 |
|
---|
[1132] | 137 | /// <summary>
|
---|
| 138 | /// Network communication Error Handler - Every network error gets logged and the connection switches to faulted state
|
---|
| 139 | /// </summary>
|
---|
| 140 | /// <param name="e">The Exception</param>
|
---|
[1371] | 141 | private void HandleNetworkError(Exception e) {
|
---|
[932] | 142 | ConnState = NetworkEnum.WcfConnState.Failed;
|
---|
[1371] | 143 | Logging.Instance.Error(this.ToString(), "exception: ", e);
|
---|
[923] | 144 | }
|
---|
| 145 |
|
---|
[1132] | 146 |
|
---|
| 147 |
|
---|
| 148 | /// <summary>
|
---|
| 149 | /// Methods for the Server Login
|
---|
| 150 | /// </summary>
|
---|
[923] | 151 | #region Login
|
---|
| 152 | public event System.EventHandler<LoginCompletedEventArgs> LoginCompleted;
|
---|
| 153 | public void LoginAsync(ClientInfo clientInfo) {
|
---|
[932] | 154 | if (ConnState == NetworkEnum.WcfConnState.Connected)
|
---|
[923] | 155 | proxy.LoginAsync(clientInfo);
|
---|
| 156 | }
|
---|
| 157 | private void proxy_LoginCompleted(object sender, LoginCompletedEventArgs e) {
|
---|
| 158 | if (e.Error == null)
|
---|
| 159 | LoginCompleted(sender, e);
|
---|
| 160 | else
|
---|
[1371] | 161 | HandleNetworkError(e.Error.InnerException);
|
---|
[923] | 162 | }
|
---|
[1097] | 163 |
|
---|
| 164 | public void LoginSync(ClientInfo clientInfo) {
|
---|
| 165 | try {
|
---|
| 166 | if (ConnState == NetworkEnum.WcfConnState.Connected) {
|
---|
| 167 | Response res = proxy.Login(clientInfo);
|
---|
[1959] | 168 | if (!res.Success) {
|
---|
| 169 | Logging.Instance.Error(this.ToString(), "Login Failed! " + res.StatusMessage);
|
---|
[2025] | 170 | HandleNetworkError(new Exception(res.StatusMessage));
|
---|
[1959] | 171 | } else {
|
---|
| 172 | ConnState = NetworkEnum.WcfConnState.Loggedin;
|
---|
| 173 | Logging.Instance.Info(this.ToString(), res.StatusMessage);
|
---|
| 174 | }
|
---|
[1097] | 175 | }
|
---|
| 176 | }
|
---|
| 177 | catch (Exception e) {
|
---|
[1371] | 178 | HandleNetworkError(e);
|
---|
[1097] | 179 | }
|
---|
| 180 | }
|
---|
| 181 |
|
---|
[923] | 182 | #endregion
|
---|
| 183 |
|
---|
[1132] | 184 | /// <summary>
|
---|
| 185 | /// Pull a Job from the Server
|
---|
| 186 | /// </summary>
|
---|
[923] | 187 | #region PullJob
|
---|
[1367] | 188 | public event System.EventHandler<SendJobCompletedEventArgs> SendJobCompleted;
|
---|
| 189 | public void SendJobAsync(Guid guid) {
|
---|
[1255] | 190 | if (ConnState == NetworkEnum.WcfConnState.Loggedin)
|
---|
[1939] | 191 | proxy.SendStreamedJobAsync(guid);
|
---|
[923] | 192 | }
|
---|
[1939] | 193 |
|
---|
| 194 | void proxy_SendStreamedJobCompleted(object sender, SendStreamedJobCompletedEventArgs e) {
|
---|
| 195 | if (e.Error == null) {
|
---|
[2117] | 196 | Stream stream = null;
|
---|
[1939] | 197 |
|
---|
[2117] | 198 | try {
|
---|
| 199 | stream = (Stream)e.Result;
|
---|
| 200 |
|
---|
| 201 | //first deserialize the response
|
---|
| 202 | BinaryFormatter formatter =
|
---|
| 203 | new BinaryFormatter();
|
---|
| 204 | ResponseJob response =
|
---|
| 205 | (ResponseJob)formatter.Deserialize(stream);
|
---|
| 206 |
|
---|
| 207 | //second deserialize the BLOB
|
---|
| 208 | MemoryStream memStream = new MemoryStream();
|
---|
| 209 | byte[] buffer = new byte[3024];
|
---|
| 210 | int read = 0;
|
---|
| 211 | while ((read = stream.Read(buffer, 0, buffer.Length)) > 0) {
|
---|
| 212 | memStream.Write(buffer, 0, read);
|
---|
| 213 | }
|
---|
| 214 |
|
---|
| 215 | SendJobCompletedEventArgs completedEventArgs =
|
---|
| 216 | new SendJobCompletedEventArgs(new object[] { response, memStream.GetBuffer() }, e.Error, e.Cancelled, e.UserState);
|
---|
| 217 | SendJobCompleted(sender, completedEventArgs);
|
---|
| 218 | }
|
---|
| 219 | finally {
|
---|
| 220 | if(stream != null)
|
---|
| 221 | stream.Dispose();
|
---|
| 222 | }
|
---|
[1939] | 223 | } else
|
---|
[1371] | 224 | HandleNetworkError(e.Error);
|
---|
[923] | 225 | }
|
---|
[1939] | 226 |
|
---|
[923] | 227 | #endregion
|
---|
| 228 |
|
---|
[1132] | 229 | /// <summary>
|
---|
| 230 | /// Send back finished Job Results
|
---|
| 231 | /// </summary>
|
---|
[923] | 232 | #region SendJobResults
|
---|
[1379] | 233 | public event System.EventHandler<StoreFinishedJobResultCompletedEventArgs> StoreFinishedJobResultCompleted;
|
---|
[1449] | 234 | public void StoreFinishedJobResultAsync(Guid clientId, Guid jobId, byte[] result, double percentage, Exception exception, bool finished) {
|
---|
[2117] | 235 | if (ConnState == NetworkEnum.WcfConnState.Loggedin) {
|
---|
| 236 | Stream stream =
|
---|
| 237 | GetStreamedJobResult(clientId, jobId, result, percentage, exception);
|
---|
| 238 |
|
---|
| 239 | proxy.StoreFinishedJobResultStreamedAsync(stream, stream);
|
---|
| 240 | }
|
---|
| 241 | }
|
---|
[1939] | 242 | private void proxy_StoreFinishedJobResultStreamedCompleted(object sender, StoreFinishedJobResultStreamedCompletedEventArgs e) {
|
---|
[2117] | 243 | Stream stream =
|
---|
| 244 | (Stream)e.UserState;
|
---|
| 245 | if (stream != null)
|
---|
| 246 | stream.Dispose();
|
---|
| 247 |
|
---|
[1939] | 248 | if (e.Error == null) {
|
---|
| 249 | StoreFinishedJobResultCompletedEventArgs args =
|
---|
| 250 | new StoreFinishedJobResultCompletedEventArgs(
|
---|
| 251 | new object[] { e.Result }, e.Error, e.Cancelled, e.UserState);
|
---|
| 252 | StoreFinishedJobResultCompleted(sender, args);
|
---|
| 253 | } else
|
---|
[1371] | 254 | HandleNetworkError(e.Error);
|
---|
[923] | 255 | }
|
---|
| 256 |
|
---|
| 257 | #endregion
|
---|
| 258 |
|
---|
[1379] | 259 | #region Processsnapshots
|
---|
| 260 | public event System.EventHandler<ProcessSnapshotCompletedEventArgs> ProcessSnapshotCompleted;
|
---|
[1449] | 261 | public void ProcessSnapshotAsync(Guid clientId, Guid jobId, byte[] result, double percentage, Exception exception, bool finished) {
|
---|
[2117] | 262 | if (ConnState == NetworkEnum.WcfConnState.Loggedin) {
|
---|
| 263 | Stream stream = GetStreamedJobResult(
|
---|
| 264 | clientId, jobId, result, percentage, exception);
|
---|
| 265 |
|
---|
| 266 | proxy.ProcessSnapshotStreamedAsync(stream, stream);
|
---|
| 267 | }
|
---|
[1379] | 268 | }
|
---|
[1939] | 269 | void proxy_ProcessSnapshotStreamedCompleted(object sender, ProcessSnapshotStreamedCompletedEventArgs e) {
|
---|
[2117] | 270 | Stream stream =
|
---|
| 271 | (Stream)e.UserState;
|
---|
| 272 | if (stream != null)
|
---|
| 273 | stream.Dispose();
|
---|
| 274 |
|
---|
[1939] | 275 | if (e.Error == null) {
|
---|
| 276 | ProcessSnapshotCompletedEventArgs args =
|
---|
| 277 | new ProcessSnapshotCompletedEventArgs(
|
---|
| 278 | new object[] { e.Result }, e.Error, e.Cancelled, e.UserState);
|
---|
| 279 |
|
---|
| 280 | ProcessSnapshotCompleted(sender, args);
|
---|
| 281 | } else
|
---|
[1379] | 282 | HandleNetworkError(e.Error);
|
---|
| 283 | }
|
---|
| 284 |
|
---|
| 285 | #endregion
|
---|
[2107] | 286 |
|
---|
[1132] | 287 | /// <summary>
|
---|
| 288 | /// Methods for sending the periodically Heartbeat
|
---|
| 289 | /// </summary>
|
---|
[923] | 290 | #region Heartbeat
|
---|
| 291 |
|
---|
[1366] | 292 | public event System.EventHandler<ProcessHeartBeatCompletedEventArgs> SendHeartBeatCompleted;
|
---|
[923] | 293 | public void SendHeartBeatAsync(HeartBeatData hbd) {
|
---|
[1255] | 294 | if (ConnState == NetworkEnum.WcfConnState.Loggedin)
|
---|
[1366] | 295 | proxy.ProcessHeartBeatAsync(hbd);
|
---|
[923] | 296 | }
|
---|
| 297 |
|
---|
[1366] | 298 | private void proxy_ProcessHeartBeatCompleted(object sender, ProcessHeartBeatCompletedEventArgs e) {
|
---|
[1936] | 299 | if (e.Error == null && e.Result.Success == true)
|
---|
[923] | 300 | SendHeartBeatCompleted(sender, e);
|
---|
[2063] | 301 | else {
|
---|
[2107] | 302 | try {
|
---|
| 303 | Logging.Instance.Error(this.ToString(), "Error: " + e.Result.StatusMessage);
|
---|
| 304 | } catch (Exception ex) {
|
---|
| 305 | Logging.Instance.Error(this.ToString(), "Error: ", ex);
|
---|
| 306 | }
|
---|
[1371] | 307 | HandleNetworkError(e.Error);
|
---|
[2063] | 308 | }
|
---|
[923] | 309 | }
|
---|
| 310 |
|
---|
[1097] | 311 | #endregion
|
---|
[1271] | 312 |
|
---|
| 313 | /// <summary>
|
---|
| 314 | /// Send back finished and Stored Job Results
|
---|
| 315 | /// </summary>
|
---|
[1939] | 316 | private Stream GetStreamedJobResult(Guid clientId, Guid jobId, byte[] result, double percentage, Exception exception) {
|
---|
[2117] | 317 | JobResult jobResult =
|
---|
| 318 | new JobResult();
|
---|
[1939] | 319 | jobResult.ClientId = clientId;
|
---|
| 320 | jobResult.JobId = jobId;
|
---|
| 321 | jobResult.Percentage = percentage;
|
---|
| 322 | jobResult.Exception = exception;
|
---|
| 323 |
|
---|
[2117] | 324 | MultiStream stream =
|
---|
| 325 | new MultiStream();
|
---|
[2099] | 326 |
|
---|
[2117] | 327 | //first send result
|
---|
| 328 | stream.AddStream(
|
---|
| 329 | new StreamedObject<JobResult>(jobResult));
|
---|
[1939] | 330 |
|
---|
[2117] | 331 | //second stream the job binary data
|
---|
| 332 | MemoryStream memStream =
|
---|
| 333 | new MemoryStream(result, false);
|
---|
| 334 | stream.AddStream(memStream);
|
---|
[1939] | 335 |
|
---|
| 336 | return stream;
|
---|
| 337 | }
|
---|
| 338 |
|
---|
[1812] | 339 | public ResponseResultReceived SendStoredJobResultsSync(Guid clientId, Guid jobId, byte[] result, double percentage, Exception exception, bool finished) {
|
---|
[1939] | 340 | return proxy.StoreFinishedJobResultStreamed(
|
---|
| 341 | GetStreamedJobResult(clientId, jobId, result, percentage, exception));
|
---|
[1271] | 342 | }
|
---|
[1450] | 343 |
|
---|
[1959] | 344 | public Response IsJobStillNeeded(Guid jobId) {
|
---|
| 345 | try {
|
---|
| 346 | return proxy.IsJobStillNeeded(jobId);
|
---|
| 347 | }
|
---|
| 348 | catch (Exception e) {
|
---|
| 349 | HandleNetworkError(e);
|
---|
| 350 | return null;
|
---|
| 351 | }
|
---|
| 352 |
|
---|
| 353 | }
|
---|
| 354 |
|
---|
[1812] | 355 | public ResponseResultReceived ProcessSnapshotSync(Guid clientId, Guid jobId, byte[] result, double percentage, Exception exception) {
|
---|
| 356 | try {
|
---|
| 357 | Logging.Instance.Info(this.ToString(), "Snapshot for Job " + jobId + " submitted");
|
---|
[1939] | 358 | return proxy.ProcessSnapshotStreamed(
|
---|
| 359 | GetStreamedJobResult(clientId, jobId, result, percentage, exception));
|
---|
[1812] | 360 | }
|
---|
| 361 | catch (Exception e) {
|
---|
| 362 | HandleNetworkError(e);
|
---|
| 363 | return null;
|
---|
| 364 | }
|
---|
| 365 | }
|
---|
| 366 |
|
---|
[1594] | 367 | public List<CachedHivePluginInfo> RequestPlugins(List<HivePluginInfo> requestedPlugins) {
|
---|
[1450] | 368 | try {
|
---|
[1939] | 369 | Stream stream = proxy.SendStreamedPlugins(requestedPlugins.ToArray());
|
---|
| 370 |
|
---|
| 371 | BinaryFormatter formatter =
|
---|
| 372 | new BinaryFormatter();
|
---|
| 373 | ResponsePlugin response = (ResponsePlugin)formatter.Deserialize(stream);
|
---|
[1635] | 374 | return response.Plugins;
|
---|
[1450] | 375 | }
|
---|
| 376 | catch (Exception e) {
|
---|
| 377 | HandleNetworkError(e);
|
---|
| 378 | return null;
|
---|
| 379 | }
|
---|
| 380 | }
|
---|
| 381 |
|
---|
[1635] | 382 | public void Logout(Guid guid) {
|
---|
| 383 | try {
|
---|
| 384 | proxy.Logout(guid);
|
---|
| 385 | }
|
---|
| 386 | catch (Exception e) {
|
---|
| 387 | HandleNetworkError(e);
|
---|
| 388 | }
|
---|
| 389 | }
|
---|
[923] | 390 | }
|
---|
| 391 | }
|
---|