public void TestInitialValues() { var message = new ServiceMessage(); Assert.IsNotNull(message.Arguments); Assert.IsNotNull(message.Stamp); }
public ActionResult Create(ServiceMessage serviceMessage) { var serviceMessageToCreate = new ServiceMessage(); TransferValues(serviceMessage, serviceMessageToCreate); if (ModelState.IsValid) { _serviceMessageRepository.EnsurePersistent(serviceMessageToCreate); // invalidate the cache System.Web.HttpContext.Current.Cache.Remove(CacheKey); Message = "ServiceMessage Created Successfully"; return RedirectToAction("Index"); } else { var viewModel = ServiceMessageViewModel.Create(Repository); viewModel.ServiceMessage = serviceMessage; return View(viewModel); } }
internal static HttpResponsePacket ToHttpResponse(HttpResponse response, ServiceMessage msg) { var rsp = new HttpResponsePacket(); foreach (var hdr in response.Headers) { // TODO: Fix adding response headers //AddHttpHeader(hdr); } //TODO: Decide if to read mostly from ServiceMessage or from response. //rsp.Version = response.... //TODO: Add a default version here rsp.StatusCode = (int)response.StatusCode; rsp.StatusDescription = ((IHttpResponseFeature)msg).ReasonPhrase; if (response.Body != null) { using (MemoryStream ms = new MemoryStream()) { response.Body.Position = 0; response.Body.CopyTo(ms); rsp.Content = ms.ToArray(); } } return rsp; }
internal static bool TryGetServiceMessage(this HttpRequestPacket request, out ServiceMessage message) { if (request == null) throw new ArgumentNullException("request"); message = new ServiceMessage(); //Build Request IHttpRequestFeature req = message as IHttpRequestFeature; Uri uri; try { uri = request.BuildUri(null, null); } catch { message = null; return false; } req.Path = uri.AbsolutePath; req.Protocol = "HTTP/" + request.Version; req.QueryString = uri.Query; req.Method = request.Method; req.Body = new MemoryStream(request.Content); //Add Request Headers { var headers = new HeaderDictionary(); foreach (var hdr in request.Headers) { //NOTE: Client already folds Request Headers into RequestPacket, so there's no need to fold it again here. headers.Add(hdr.Key, hdr.Value.ToArray()); } req.Headers = headers; } //Create Response IHttpResponseFeature resp = message as IHttpResponseFeature; resp.StatusCode = 200; //Add Response Headers resp.Body = new MemoryStream(); { var headers = new HeaderDictionary(); headers.Add("Server", HTTP_RESPONSE_SERVER); resp.Headers = headers; //TODO: Something to think about: Should host add Date response header. //If so, shouldn't that be done at the time that the response is been transmitted //In which case, the subscriber should be responsible for adding/overwriting that value. //In any case, remember DateTime.UtcNow/Now is very slow, so use Environment.TickCount in addition to some //other mechanism that limits the number of times, DateTime.UtcNow is polled. } return true; }
public ServiceMessage ExecuteMessage(ServiceMessage message) { if (this.PollServiceSleep > 0) { Thread.Sleep(ExecuteMessageSleep); } return new ServiceMessage(); }
public ServiceResponse<List<FC.Shared.Entities.UFestival>> Search([FromBody]JObject payload) { ServiceMessage<SearchFilter> filter = new ServiceMessage<SearchFilter>(payload); List<UFestival> tmp = new List<UFestival>(); tmp = FR.Search(filter.Data.Keyword); return new ServiceResponse<List<UFestival>>(tmp, HttpStatusCode.OK, "Search-SUCCESS"); }
public void TestDispose() { var message = new ServiceMessage(); message.Dispose(); Assert.IsNull(message.Arguments); Assert.IsNull(message.Name); }
public ServiceResponse<bool> HasAuth([FromBody]JObject payload) { ServiceMessage<IsAuthMsg> filter = new ServiceMessage<IsAuthMsg>(payload); if (this.AuthRepo.Authenticated(filter.Data.SessionID)) { return new ServiceResponse<bool>(true, HttpStatusCode.OK, "SUCCESS-HasAuth"); } else { return new ServiceResponse<bool>(false, HttpStatusCode.OK, "SUCCESS-HasAuth"); } }
internal static ServiceMessage ToServiceMessage(this HttpRequestPacket request) { if (request == null) throw new ArgumentNullException("request"); var message = new ServiceMessage(); IHttpRequestFeature reqRes = message as IHttpRequestFeature; if(request.Resource != null) { //TODO: Is QueryString Part of result.Path or is it clipped //Should probably use GetUriFromResource() method to Parse Path, QueryString, PathBase AND PROTOCOL properly if (request.Resource.StartsWith("/")) { reqRes.Path = request.Resource; } else { reqRes.Path = "/" + request.Resource; } } reqRes.Protocol = "HTTP/1.1"; //TODO: Change this reqRes.QueryString = ""; //TODO: Get QueryString properly, { var headers = new Dictionary<string, Microsoft.Framework.Primitives.StringValues>(); foreach (var hdr in request.Headers) { headers.Add(hdr.Key, new Microsoft.Framework.Primitives.StringValues(hdr.Value.ToArray())); } reqRes.Headers = headers; } reqRes.Method = request.Method; reqRes.Body = new MemoryStream(request.Content); //Response IHttpResponseFeature resp = message as IHttpResponseFeature; resp.Body = new MemoryStream(); //TODO: How expensive is a brand new memorystream? { var headers = new Dictionary<string, Microsoft.Framework.Primitives.StringValues>(); //foreach (var hdr in request.Headers) //{ // headers.Add(hdr.Key, new Microsoft.Framework.Primitives.StringValues(hdr.Value.ToArray())); //} //reqRes.Headers = headers; resp.Headers = new Dictionary<string, Microsoft.Framework.Primitives.StringValues>(); //TODO: Change this so it's read off a new response parameter object } resp.StatusCode = 200; return message; }
public ServiceResponse<List<UBanner>> GetFiltered([FromBody]JObject payload) { ServiceMessage<BannerFilter> filter = new ServiceMessage<BannerFilter>(payload); List<UBanner> result = br.GetBannersByLayout(filter.Data.Layout); List<UBanner> retResult = new List<UBanner>(); foreach(UBanner u in result) { retResult.Add(new UBanner(u)); } return new ServiceResponse<List<UBanner>>(retResult, HttpStatusCode.OK, "SUCCESS-FestivalController-GetFiltered"); }
private Task DispatchMessageAsync(ServiceMessage message) { switch (message) { case OpenConnectionMessage openConnectionMessage: return(OnConnectedAsync(openConnectionMessage)); case CloseConnectionMessage closeConnectionMessage: return(OnDisconnectedAsync(closeConnectionMessage)); case ConnectionDataMessage connectionDataMessage: return(OnMessageAsync(connectionDataMessage)); case PingMessage _: // ignore ping break; } return(Task.CompletedTask); }
/// <summary> /// Обработка и ответ сообщения от клиента /// </summary> /// <param name="data"></param> /// <returns></returns> public ServiceMessage _Execute(ServiceMessage data) { var result = default(ServiceMessage); DCT.DCT.Execute(c => { var request = (RequestMessageBase)data.Desirialize(); c._SessionInfo.HashUID = request.HashUID; c._SessionInfo.SessionUID = request.SessionUID; var response = request._Execute(this, request); if (response == null) { throw new NullReferenceException($"Request - {data.FullName}. Ошибка ответа - Response не может быть null, если метод вызывает асинхронно, необходимо вернуть ответ о успешно принятом сообщении"); } //var typeResponse = CheckResponseType(serviceInstance, response.GetType().FullName); result = ServiceMessage.New(response); }); return(result); }
public ServiceMessage Send(ServiceMessage message) { if (!message.Type.Equals(typeof(PrintRequest)) && !message.Type.Equals(typeof(String))) { throw new WrongMessageTypeException("MenuService: Wrong message type: " + message.Type); } if (message.Type.Equals(typeof(String))) { handle((String)message.Message); } if (message.Type.Equals(typeof(PrintRequest))) { printService.Send(new ServiceMessage(typeof(String), message.Message)); } return(null); }
public ActionResult Edit(BanReasonEditViewModel model) { bool succeeded = false; if (ModelState.IsValid) { model.Id = HttpUtility.UrlDecode(model.Id); BanReasonEditDTO banReasonDTO = Mapper.Map <BanReasonEditViewModel, BanReasonEditDTO>(model); ServiceMessage serviceMessage = service.Edit(banReasonDTO); if (!serviceMessage.Succeeded) { AddModelErrors(serviceMessage.Errors); } succeeded = serviceMessage.Succeeded; } return(JsonOnFormPost(succeeded, "~/Views/BanReason/Edit.cshtml", model)); }
public async Task VisitWcfAsync(ServiceMessage message) { var fabricClient = new FabricClient(FabricClientRole.Admin); var partitionList = await fabricClient.QueryManager.GetPartitionListAsync(new Uri(Service3Uri)); var bindings = WcfUtility.CreateTcpClientBinding(); var partitionResolver = ServicePartitionResolver.GetDefault(); message.StampTwo.Visited = true; message.StampTwo.TimeNow = DateTime.UtcNow; foreach (var partition in partitionList) { var partitionInfo = (Int64RangePartitionInformation)partition.PartitionInformation; var wcfClientProxy = new WcfCommunicationClientFactory <IServiceThree>(clientBinding: bindings, servicePartitionResolver: partitionResolver); var wcfClient = new SvcThreeWcfCommunicationClient(wcfClientProxy, new Uri(Service3Uri), new ServicePartitionKey(partitionInfo.HighKey), listenerName: "WcfTcp"); await wcfClient.InvokeWithRetryAsync(client => client.Channel.VisitWcfAsync(message)); } }
void ParseServiceMessage(ServiceMessage message) { switch (message.Name) { case ServiceMessageNames.SetVariable.Name: var variableName = message.GetValue(ServiceMessageNames.SetVariable.NameAttribute); var variableValue = message.GetValue(ServiceMessageNames.SetVariable.ValueAttribute); if (!string.IsNullOrWhiteSpace(variableName)) { outputVariables.Set(variableName, variableValue); } break; case ServiceMessageNames.CalamariFoundPackage.Name: CalamariFoundPackage = true; break; case ServiceMessageNames.FoundPackage.Name: var foundPackageId = message.GetValue(ServiceMessageNames.FoundPackage.IdAttribute); var foundPackageVersion = message.GetValue(ServiceMessageNames.FoundPackage.VersionAttribute); var foundPackageVersionFormat = message.GetValue(ServiceMessageNames.FoundPackage.VersionFormat); var foundPackageHash = message.GetValue(ServiceMessageNames.FoundPackage.HashAttribute); var foundPackageRemotePath = message.GetValue(ServiceMessageNames.FoundPackage.RemotePathAttribute); var fileExtension = message.GetValue(ServiceMessageNames.FoundPackage.FileExtensionAttribute); FoundPackage = new FoundPackage(foundPackageId, foundPackageVersion, foundPackageVersionFormat, foundPackageRemotePath, foundPackageHash, fileExtension); break; case ServiceMessageNames.PackageDeltaVerification.Name: var pdvHash = message.GetValue(ServiceMessageNames.PackageDeltaVerification.HashAttribute); var pdvSize = message.GetValue(ServiceMessageNames.PackageDeltaVerification.SizeAttribute); var pdvRemotePath = message.GetValue(ServiceMessageNames.PackageDeltaVerification.RemotePathAttribute); DeltaError = message.GetValue(ServiceMessageNames.PackageDeltaVerification.Error); if (pdvHash != null) { DeltaVerification = new DeltaPackage(pdvRemotePath, pdvHash, long.Parse(pdvSize)); } break; } }
public ActionResult Edit(CategoryEditViewModel model) { if (ModelState.IsValid) { model.Id = HttpUtility.UrlDecode(model.Id); CategoryEditDTO categoryDTO = Mapper.Map <CategoryEditViewModel, CategoryEditDTO>(model); ServiceMessage serviceMessage = service.Edit(categoryDTO); if (serviceMessage.Succeeded) { return(RedirectToAction("List")); } else { AddModelErrors(serviceMessage.Errors); } } return(View(model)); }
/// <summary> /// Write a message to the first connected server connection /// </summary> public async Task WriteMessageAsync(ServiceMessage message) { foreach (var connection in ServiceConnections) { if (connection.Value.Status == ServiceConnectionStatus.Connecting) { await connection.Value.ConnectionInitializedTask; } if (connection.Value.Status == ServiceConnectionStatus.Connected) { var context = ConnectionContexts[connection.Key]; SharedServiceProtocol.WriteMessage(message, context.Application.Output); await context.Application.Output.FlushAsync(); return; } } }
//Обработка нажатия на кнопку "Добавить вопрос в базу" private void OnAddButton(object sender, EventArgs e) { string caption = "Info"; var message = ""; MessageBoxButtons buttons = MessageBoxButtons.OK; //Проверяем, что введенных данных достаточно для добавления вопроса в базу if (QTextBox.Text == null || TextVar1.Text == null || TextVar2.Text == null || VarComboBox.SelectedItem == null || (TextVar3.Text == null && TextVar4.Text != null)) { message = "Вопрос не может быть добавлен. Недостаточно данных."; } else if ((VarComboBox.SelectedItem.ToString() == "3" && TextVar3.Text == null) || (VarComboBox.SelectedItem.ToString() == "4" && TextVar4.Text == null)) { message = "Вопрос не может быть добавлен. Вариант, выбранный в качестве правильного, пуст."; } if (message != "") { MessageBox.Show(message, caption, buttons); } else { //Создаем объет "Вопрос" и инициализируем его введенными в поля формы данными var question = new Question(QTextBox.Text, Convert.ToString(VarComboBox.SelectedItem), TextVar1.Text, TextVar2.Text, TextVar3.Text, TextVar4.Text); //Отправляем сообщение на сервер ServiceMessage msg = new ServiceMessage(question, Command.AddQuestion); _server.Write(msg); message = "Вопрос успешно добавлен в базу."; MessageBox.Show(message, caption, buttons); //Закрываем форму this.Close(); } }
public int LogOn() { try { var creds = new LogonCredentials { Login = this.Login, Password = this.password }; var serializedCreds = creds.ToBytes(); var serviceMessage = new ServiceMessage { MessageType = MessageType.Logon, Data = serializedCreds }; this.cryptoWrapper.Send(serviceMessage.ToBytes()); var respData = this.cryptoWrapper.Receive(); var smr = ServiceMessageResponse.FromBytes(respData); if (smr.IsSuccess) { Logger.Debug(string.Format("Logon succeeded for user '{0}'", this.Login)); return(0); } else { Logger.Debug(string.Format("Logon failed for user '{0}'. Reason: '{1}'", this.Login, smr.Message)); this.FreeClient(); return(1); } } catch (ArgumentNullException ex) { Logger.Error(ex.ToString); return(3); } catch (SocketException ex) { Logger.Error(ex.ToString); return(4); } catch (Exception ex) { Logger.Error(ex.ToString); return(5); } }
public IActionResult Contact(ServiceMessageViewModel model) { if (model != null) { var messageModel = new ServiceMessage { RecieverEmail = model.RecieverEmail, RecieverName = model.RecieverName, SenderEmail = model.SenderEmail, SenderName = model.SenderName, SenderPassword = model.SenderPassword, Subject = model.Subject, Text = model.Text }; messageService.MessageToCustomerService(messageModel); RedirectToAction("Success"); } return(View(model)); }
/// <inheritdoc /> public void WriteMessage(ServiceMessage message, IBufferWriter <byte> output) { var memoryBufferWriter = MemoryBufferWriter.Get(); try { var writer = new MessagePackWriter(memoryBufferWriter); // Write message to a buffer so we can get its length WriteMessageCore(ref writer, message); // Write length then message to output BinaryMessageFormatter.WriteLengthPrefix(memoryBufferWriter.Length, output); memoryBufferWriter.CopyTo(output); } finally { MemoryBufferWriter.Return(memoryBufferWriter); } }
public ServiceResponse<bool> Create([FromBody]JObject payload) { ServiceMessage<UArtist> artist = new ServiceMessage<UArtist>(payload); bool result = false; string msg = ""; HttpStatusCode code = HttpStatusCode.InternalServerError; try { repo.Create(artist.Data); result = true; msg = "SUCCESS-Artist/Create"; code = HttpStatusCode.OK; } catch (Exception ex) { msg = "FAILURE-Artist/Create - " + ex.Message; result = false; } return new ServiceResponse<bool>(result, code, msg); }
private Task WriteMultiEndpointMessageAsync(ServiceMessage serviceMessage, Func <IServiceConnectionContainer, Task> inner) { var routed = GetRoutedEndpoints(serviceMessage)? .Select(endpoint => { if (ConnectionContainers.TryGetValue(endpoint, out var connection)) { return(e: endpoint, c: connection); } Log.EndpointNotExists(_logger, endpoint.ToString()); return(e: endpoint, c: null); }) .Where(c => c.c != null) .Select(async s => { try { await inner(s.c); } catch (ServiceConnectionNotActiveException) { // log and don't stop other endpoints Log.FailedWritingMessageToEndpoint(_logger, serviceMessage.GetType().Name, s.e.ToString()); } }).ToArray(); if (routed == null || routed.Length == 0) { // check if the router returns any endpoint Log.NoEndpointRouted(_logger, serviceMessage.GetType().Name); return(Task.CompletedTask); } if (routed.Length == 1) { return(routed[0]); } return(Task.WhenAll(routed)); }
private void Edit(TournamentBaseModel tournament, IEnumerable <ParticipantBaseModel> tournamentParticipants, IEnumerable <ParticipantBaseModel> sportParticipants) { TournamentManageViewModel viewModel = new TournamentManageViewModel(tournament, tournamentParticipants, sportParticipants); TournamentManageControl control = new TournamentManageControl(viewModel); Window window = WindowFactory.CreateByContentsSize(control); viewModel.InfoViewModel.TournamentEdited += (s, e) => { TournamentEditModel tournamentEditModel = e.Tournament; TournamentEditDTO tournamentEditDTO = Mapper.Map <TournamentEditModel, TournamentEditDTO>(tournamentEditModel); using (ITournamentService service = factory.CreateTournamentService()) { ServiceMessage serviceMessage = service.Update(tournamentEditDTO); RaiseReceivedMessageEvent(serviceMessage.IsSuccessful, serviceMessage.Message); if (serviceMessage.IsSuccessful) { Notify(); } } }; viewModel.ParticipantViewModel.TournamentEdited += (s, e) => { TournamentEditModel tournamentEditModel = e.Tournament; TournamentEditDTO tournamentEditDTO = Mapper.Map <TournamentEditModel, TournamentEditDTO>(tournamentEditModel); using (ITournamentService service = factory.CreateTournamentService()) { ServiceMessage serviceMessage = service.UpdateParticipants(tournamentEditDTO); RaiseReceivedMessageEvent(serviceMessage.IsSuccessful, serviceMessage.Message); if (serviceMessage.IsSuccessful) { Notify(); } } }; window.Show(); }
private void Edit(EventDisplayModel eventDisplayModel, IEnumerable <ParticipantBaseModel> allParticipants) { EventManageViewModel viewModel = new EventManageViewModel(eventDisplayModel, allParticipants); EventManageControl control = new EventManageControl(viewModel); Window window = WindowFactory.CreateByContentsSize(control); viewModel.InfoViewModel.EventEdited += (s, e) => { EventEditModel eventEditModel = e.Event; EventEditDTO eventEditDTO = Mapper.Map <EventEditModel, EventEditDTO>(eventEditModel); using (IEventService service = factory.CreateEventService()) { ServiceMessage serviceMessage = service.Update(eventEditDTO); RaiseReceivedMessageEvent(serviceMessage); if (serviceMessage.IsSuccessful) { Notify(); } } }; viewModel.EventParticipantViewModel.EventEdited += (s, e) => { EventEditModel eventEditModel = e.Event; EventEditDTO eventEditDTO = Mapper.Map <EventEditModel, EventEditDTO>(eventEditModel); using (IEventService service = factory.CreateEventService()) { ServiceMessage serviceMessage = service.UpdateParticipants(eventEditDTO); RaiseReceivedMessageEvent(serviceMessage); if (serviceMessage.IsSuccessful) { Notify(); } } }; window.Show(); }
// From RFC 6763 // An empty TXT record containing zero strings is not allowed[RFC1035]. // DNS-SD implementations MUST NOT emit empty TXT records.DNS-SD // clients MUST treat the following as equivalent: // // o A TXT record containing a single zero byte. // (i.e., a single empty string.) // o An empty(zero-length) TXT record. // (This is not strictly legal, but should one be received, it should // be interpreted as the same as a single empty string.) // o No TXT record. // (i.e., an NXDOMAIN or no-error-no-answer response.) // public override byte[] GetBytes() { var ms = new MemoryStream(); var writer = new BinaryWriter(ms); writer.Write(base.GetBytes()); writer.Write(ServiceMessage.HostToNetworkOrder((uint)Flags)); writer.Write(ServiceMessage.HostToNetworkOrder(InterfaceIndex)); writer.Write(ServiceMessage.GetMessageStringBytes(InstanceName)); writer.Write(ServiceMessage.GetMessageStringBytes(ServiceType)); writer.Write(ServiceMessage.GetMessageStringBytes(Domain)); writer.Write(ServiceMessage.GetMessageStringBytes(HostName)); writer.Write(ServiceMessage.HostToNetworkOrder(Port)); writer.Write(ServiceMessage.HostToNetworkOrder((ushort)(TxtRecord?.Length ?? 0))); if (TxtRecord != null) { writer.Write(TxtRecord); } return(ms.ToArray()); }
private static async Task SendAsync(ServiceMessage message, string host, int port) { var group = new MultithreadEventLoopGroup(); var bootstrap = new Bootstrap(); bootstrap .Group(group) .Channel <TcpSocketChannel>() .Option(ChannelOption.TcpNodelay, true) .Handler(new ActionChannelInitializer <ISocketChannel>(channel => { IChannelPipeline pipeline = channel.Pipeline; pipeline.AddLast(new LoggingHandler()); pipeline.AddLast(new StringEncoder(Encoding.UTF8), new StringDecoder(Encoding.UTF8)); })); IChannel clientChannel = await bootstrap.ConnectAsync(new IPEndPoint(IPAddress.Parse(host), port)); var payload = JsonConvert.SerializeObject(message); await clientChannel.WriteAndFlushAsync(payload); }
private Task DispatchMessageAsync(ServiceMessage message) { switch (message) { case OpenConnectionMessage openConnectionMessage: return(OnConnectedAsync(openConnectionMessage)); case CloseConnectionMessage closeConnectionMessage: return(OnDisconnectedAsync(closeConnectionMessage)); case ConnectionDataMessage connectionDataMessage: return(OnMessageAsync(connectionDataMessage)); case ServiceErrorMessage serviceErrorMessage: return(OnServiceErrorAsync(serviceErrorMessage)); case PingMessage pingMessage: return(OnPingMessageAsync(pingMessage)); } return(Task.CompletedTask); }
public ServiceMessage Send(ServiceMessage message) { if (!message.Type.Equals(typeof(String)) && !message.Type.Equals(typeof(PrintRequest)) && !message.Type.Equals(typeof(MenuCommand))) { throw new WrongMessageTypeException("ServiceMessage: Wrong message type: " + message.Type); } if (message.Type.Equals(typeof(MenuCommand))) { String query = (String)(((MenuCommand)message.Message).Name); switch (query) { case "list": catalog.SearchAll(); break; case "search author": catalog.SearchByAuthorName((String)((MenuCommand)message.Message).Arg); break; case "search name": catalog.SearchByTrackName((String)((MenuCommand)message.Message).Arg); break; case "add": catalog.Add(((MenuCommand)message.Message).Arg, ((MenuCommand)message.Message).Arg); break; case "del": catalog.Remove(((MenuCommand)message.Message).Arg, ((MenuCommand)message.Message).Arg); break; } } if (message.Type.Equals(typeof(PrintRequest))) { printService.Send(new ServiceMessage(typeof(String), message.Message)); } return null; }
public async Task ServiceTransportStartTest() { var cm = new RequestMessage(OperationCode.ConnectionRequest); ServiceMessage rm = null; var aConnectionClosed = false; // Called by ReceiveLoop, handle exceptions // Aka don't assert in these void ProcessCallbackMessage(CallbackMessage message, bool moreComing) { } void ServiceTransportConnectionClosed(ConnectionClosedReason reason) { aConnectionClosed = true; } // Called by ReceiveLoop, handle exceptions // Aka don't assert in these async void ProcessRequestMessage(RequestMessage message) { rm = message; await _provider.Connector.SendToRemote(ServiceError.NoError); } void ServiceTransportConnectorClosed(ConnectionClosedReason reason) { aConnectionClosed = true; } _provider.Connector.Start(ProcessRequestMessage, ServiceTransportConnectorClosed); await _transport.StartAsync(cm, ProcessCallbackMessage, ServiceTransportConnectionClosed); if (aConnectionClosed) { throw new Exception("A connection was closed unexpectedly"); } cm.Should().BeEquivalentTo(rm); }
void WriteTargetCreationServiceMessage(KubernetesCluster cluster, TargetMatchResult matchResult, TargetDiscoveryScope scope) { var parameters = new Dictionary <string, string> { { "name", cluster.Name }, { "clusterName", cluster.ClusterName }, { "clusterUrl", cluster.Endpoint }, { "clusterResourceGroup", cluster.ResourceGroupName }, { "clusterAdminLogin", null }, { "namespace", null }, { "skipTlsVerification", bool.TrueString }, { "octopusDefaultWorkerPoolIdOrName", cluster.WorkerPool ?? scope.WorkerPoolId }, { "octopusAccountIdOrName", cluster.AccountId }, { "octopusClientCertificateIdOrName", null }, { "octopusServerCertificateIdOrName", null }, { "octopusRoles", matchResult.Role }, { "healthCheckContainerImageFeedIdOrName", null }, { "healthCheckContainerImage", null }, { "updateIfExisting", bool.TrueString }, { "isDynamic", bool.TrueString }, { "clusterProject", null }, { "clusterRegion", null }, { "clusterZone", null }, { "clusterImpersonateServiceAccount", null }, { "clusterServiceAccountEmails", null }, { "clusterUseVmServiceAccount", null }, { "awsUseWorkerCredentials", cluster.AwsUseWorkerCredentials.ToString() }, { "awsAssumeRole", (cluster.AwsAssumeRole != null).ToString() }, { "awsAssumeRoleArn", cluster.AwsAssumeRole?.Arn }, { "awsAssumeRoleSession", cluster.AwsAssumeRole?.Session }, { "awsAssumeRoleSessionDurationSeconds", cluster.AwsAssumeRole?.SessionDuration?.ToString() }, { "awsAssumeRoleExternalId", cluster.AwsAssumeRole?.ExternalId } }; var serviceMessage = new ServiceMessage( CreateKubernetesTargetServiceMessageName, parameters.Where(p => p.Value != null) .ToDictionary(p => p.Key, p => p.Value)); log.WriteServiceMessage(serviceMessage); }
private void QueryAddins() { if (ServerState.Instance.ServerService != null) { ServiceMessage message = new ServiceMessage(); message.Message = MessageNames.IsAddinHealthy; message.Broadcast = true; try { // (05.23.2019) // If the administrative pipe is not connected, this can cause the StorageServerManager.exe UI to crash // I noticed this when the CSDicomHighLevelClient demo does a move, and I stop/start the CSStorageServerManger.exe listening service during the move // The UI will sometimes crash ServerState.Instance.ServerService.SendMessage(message); } catch (Exception) { // Console.WriteLine(ex.Message); } } }
public ServiceResponse<AppUserSession> Login([FromBody]JObject payload) { ServiceMessage<LoginMsg> filter = new ServiceMessage<LoginMsg>(payload); AppUserSession sess =this.AuthRepo.Login(filter.Data.Username, filter.Data.PassOrCode, System.Web.HttpContext.Current, this.ControllerContext); if(sess != null && sess.Authenticated) { HttpCookie cook = new HttpCookie("AUTHENTICATED", sess.SessionID.Value.ToString()); cook.Path = "/"; cook.Expires = sess.Expires; HttpCookie cook2 = new HttpCookie("MEDIA_AUTH", sess.SessionID.Value.ToString()); cook2.Path = "/"; cook2.Expires = sess.Expires; cook2.Domain = "media.festival-calendar.nl"; HttpContext.Current.Response.SetCookie(cook); HttpContext.Current.Response.SetCookie(cook2); return new ServiceResponse<AppUserSession>(sess, HttpStatusCode.OK, "SUCCESS-AuthController-Login"); } else { return new ServiceResponse<AppUserSession>(null, HttpStatusCode.Unauthorized, "SUCCESS-AuthController-Login"); } }
public UIElement GetAddElement() { CountryCreateViewModel viewModel = new CountryCreateViewModel(); CountryCreateControl control = new CountryCreateControl(viewModel); viewModel.CountryCreated += (s, e) => { using (ICountryService service = factory.CreateCountryService()) { ServiceMessage serviceMessage = service.Create(e.ContryName); RaiseReceivedMessageEvent(serviceMessage.IsSuccessful, serviceMessage.Message); if (serviceMessage.IsSuccessful) { viewModel.CountryName = String.Empty; Notify(); } } }; return(control); }
private Task DispatchMessageAsync(ServiceMessage message) { switch (message) { case OpenConnectionMessage openConnectionMessage: return(OnConnectedAsync(openConnectionMessage)); case CloseConnectionMessage closeConnectionMessage: return(OnDisconnectedAsync(closeConnectionMessage)); case ConnectionDataMessage connectionDataMessage: return(OnMessageAsync(connectionDataMessage)); case ServiceErrorMessage serviceErrorMessage: return(OnServiceErrorAsync(serviceErrorMessage)); case PingMessage pingMessage: // TODO: Call OnPingMessageAsync when the full pipeline is completed. break; } return(Task.CompletedTask); }
public ServiceMessage Process(ServiceMessage Message) { ServiceMessage serviceMessage = null; switch (Message.Message) { //case MessageNames.IsAddinHealthy: // serviceMessage = new ServiceMessage(); // string error; // serviceMessage.Message = Message.Message; // serviceMessage.Success = CanAccessDatabase(out error); // serviceMessage.Error = error; // break; case PatientRestrictMessage.SettingsChanged: DicomUtilities.DebugString(DebugStringOptions.ShowCounter, "Received 'PatientRestrictMessage.SettingsChanged' Message"); AdvancedSettings settings = AdvancedSettings.Open(Module.ServiceDirectory); Module.ConfigureAddin(settings); break; } return(serviceMessage); }
/// <summary> /// Инициализация и запуск сервера сообщений /// </summary> public void StartServer() { ThrottlingBehaviorInit(); TcpBindingInit(); MetadataBehaviorInit(); ServiceMessage.AppendLine($"MaxConcurrentCalls {MaxConcurrentCalls}"); ServiceMessage.AppendLine($"MaxConcurrentSessions {MaxConcurrentSessions}"); ServiceMessage.AppendLine($"MaxConcurrentSessions {MaxConcurrentSessions}"); ServiceMessage.AppendLine($"MaxSizeBuffer {MaxSizeBuffer}"); try { host.Open(); Open = true; ServiceMessage.AppendLine("Start Ok"); } catch (Exception ex) { Open = false; ServiceMessage.AppendLine(ex.Message); } }
private async Task VisitSocketAsync(ServiceMessage message) { byte[] receiveBuffer = new byte[102400]; try { if (cws == null) { cws = new ClientWebSocket(); var endpoint = await Utils.GetSocketEndpoint("Service3", this.Context); await cws.ConnectAsync(new Uri(endpoint), CancellationToken.None); } //cws = new ClientWebSocket(); //var endpoint = await Utils.GetSocketEndpoint("Service3", this.Context); //await cws.ConnectAsync(new Uri(endpoint), CancellationToken.None); var messageJson = JsonConvert.SerializeObject(message); Task receiverTask = cws.ReceiveAsync(new ArraySegment <byte>(receiveBuffer), CancellationToken.None); Task sendTask = cws.SendAsync(new ArraySegment <byte>(Encoding.UTF8.GetBytes(messageJson)), WebSocketMessageType.Binary, true, CancellationToken.None); await Task.WhenAll(receiverTask, sendTask); } catch (Exception e) { LogError(e); } //finally //{ // if (cws?.State == WebSocketState.Open || cws?.State == WebSocketState.Connecting) // { // await cws.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None); // } //} }
// обработчик события "очистка экрана" private void OnServiceMessage(object sender, IncommingMessageEventArgs <ServiceMessage> e) { // если такого клиента, который прислал линию, ещё нет в списке, добавить его в список if (!_clientList.Contains(e.Sender.Address)) { _clientList.Add(e.Sender.Address); } if (e.Message.Command == Command.CleanScreen) { //для каждого клиента в списке подключенных foreach (var client in _clientList) { _client = NetworkingFactory.UdpWriter <ServiceMessage>(client, Ports.SMServerPort); var msg = new ServiceMessage(Command.CleanScreen); linesList = new List <Lines>(); clear(); _client.Write(msg); _client.Dispose(); } } else if (e.Message.Command == Command.GetPic) { try { Monitor.Enter(panel1); Monitor.Enter(pic); _client_pictures = NetworkingFactory.UdpWriter <Pictures>(e.Sender.Address, Ports.PictPort); var msg = new Pictures(pic); _client_pictures.Write(msg); } finally { Monitor.Exit(panel1); Monitor.Exit(pic); } } }
public CommandResult MakePurchase(WPWithinService service) { service.SetupDevice("my-device", "an example consumer device"); ServiceMessage firstDevice = DiscoverDevices(service)?.FirstOrDefault(); if (firstDevice == null) { return(CommandResult.NonCriticalError); } connectToDevice(service, firstDevice); ServiceDetails firstService = GetAvailableServices(service)?.FirstOrDefault(); if (firstService == null) { return(CommandResult.NonCriticalError); } Price firstPrice = GetServicePrices(service, firstService.ServiceId.Value)?.FirstOrDefault(); if (firstPrice == null) { return(CommandResult.NonCriticalError); } TotalPriceResponse priceResponse = GetServicePriceQuote(service, firstService.ServiceId.Value, 1, firstPrice.Id.Value); if (priceResponse == null) { return(CommandResult.CriticalError); } PurchaseService(service, firstService.ServiceId.Value, priceResponse); return(CommandResult.Success); }
public void WriteFile(string teamCityArtifactUri, string description = "") { if (string.IsNullOrEmpty(teamCityArtifactUri)) { throw new ArgumentException(nameof(teamCityArtifactUri)); } if (description == null) { throw new ArgumentNullException(nameof(description)); } var message = new ServiceMessage("testMetadata") { { "testName", _testName }, { "type", "artifact" }, { "value", teamCityArtifactUri } }; if (!string.IsNullOrEmpty(description)) { message.Add("name", description); } PostMessage(message); }
private static ServiceMessage CreateResponse(HttpStatusCode status, string reasonPhrase, string body = null) { var msg = new ServiceMessage(); ((Microsoft.AspNet.Http.Features.IHttpResponseFeature)msg).StatusCode = (int)status; ((Microsoft.AspNet.Http.Features.IHttpResponseFeature)msg).ReasonPhrase = reasonPhrase; if(body != null) { ((Microsoft.AspNet.Http.Features.IHttpResponseFeature)msg).Body = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(body)); } return msg; }
/// <summary> /// Transfer editable values from source to destination /// </summary> private static void TransferValues(ServiceMessage source, ServiceMessage destination) { //Recommendation: Use AutoMapper Mapper.Map(source, destination); //throw new NotImplementedException(); }
public ActionResult Edit(int id, ServiceMessage serviceMessage) { var serviceMessageToEdit = _serviceMessageRepository.GetNullableById(id); if (serviceMessageToEdit == null) return RedirectToAction("Index"); TransferValues(serviceMessage, serviceMessageToEdit); if (ModelState.IsValid) { _serviceMessageRepository.EnsurePersistent(serviceMessageToEdit); // invalidate the cache System.Web.HttpContext.Current.Cache.Remove(CacheKey); Message = "ServiceMessage Edited Successfully"; return RedirectToAction("Index"); } else { var viewModel = ServiceMessageViewModel.Create(Repository); viewModel.ServiceMessage = serviceMessage; return View(viewModel); } }
public ServiceResponse<List<ContentDetail>> GetFiltered([FromBody]JObject payload) { ServiceMessage<NewsFilter> filter = new ServiceMessage<NewsFilter>(payload); return new ServiceResponse<List<ContentDetail>>(repo.GetSysNews(filter.Data), HttpStatusCode.OK, "SUCCESS-NewsController-GetFiltered"); }
public ServiceResponse<bool> Logout([FromBody]JObject payload) { ServiceMessage<LogoutMsg> filter = new ServiceMessage<LogoutMsg>(payload); bool status = this.AuthRepo.Logout(filter.Data.SessionID); return new ServiceResponse<bool>(status, HttpStatusCode.OK, "SUCCESS-HasAuth"); }
public void SendMessage(ServiceMessage message) { MessageBox.Show(message.Message[0].ToString()); }
public ServiceResponse<bool> Create([FromBody]JObject payload) { if (this.IsAuthorized(new string[] { "FestivalAdmin", "Admin" })) { ServiceMessage<UFestival> festival = new ServiceMessage<UFestival>(payload); bool result = false; string msg = ""; HttpStatusCode code = HttpStatusCode.InternalServerError; try { FestivalRepository.Create(festival.Data); result = true; msg = "SUCCESS-Festival/Create"; code = HttpStatusCode.OK; } catch (Exception ex) { msg = "FAILURE-Festival/Create - " + ex.Message; result = false; } return new ServiceResponse<bool>(result, code, msg); } else { throw NotAuthorized(); } }
public ServiceMessage ExecuteMessage(ServiceMessage message) { throw new NotImplementedException(); }
public ServiceMessage ExecuteMessage(ServiceMessage message) { this.OnExecuteMessage = true; return this.ExecuteResultMessage; }
public static ServiceMessage ServiceMessage(int? counter) { var rtValue = new ServiceMessage(); rtValue.Message = "Message" + counter.Extra(); return rtValue; }
protected bool Equals(ServiceMessage other) { return string.Equals(Category, other.Category) && string.Equals(Message, other.Message); }
public ServiceResponse<List<UFestival>> GetFiltered([FromBody]JObject payload) { ServiceMessage<FestivalFilter> filter = new ServiceMessage<FestivalFilter>(payload); List<UFestival> result = FestivalRepository.GetFilteredFestival(filter.Data); return new ServiceResponse<List<UFestival>>(result, HttpStatusCode.OK, "SUCCESS-FestivalController-GetFiltered"); }
public string Rate([FromBody]JObject payload) { ServiceMessage<RatingMsg> svcMsg = new ServiceMessage<RatingMsg>(payload); RatingRepo.Rate(svcMsg.Data, System.Web.HttpContext.Current.Request.UserHostAddress, System.Web.HttpContext.Current.Request.UserHostName); return "true"; }
public ServiceResponse<bool> Update([FromBody]JObject payload) { ServiceMessage<UCountry> country = new ServiceMessage<UCountry>(payload); bool result = false; string msg = ""; HttpStatusCode code = HttpStatusCode.InternalServerError; try { repo.Update(country.Data); result = true; msg = "SUCCESS-Country/Update"; code = HttpStatusCode.OK; } catch (Exception ex) { msg = "FAILURE-Country/Update - " + ex.Message; result = false; } return new ServiceResponse<bool>(result, code, msg); }
public ServiceResponse<bool> CreateDirectory([FromBody]JObject payload) { ServiceMessage<MediaDirectoryMsg> media = new ServiceMessage<MediaDirectoryMsg>(payload); repo.CreateMediaDirectory(media.Data); return new ServiceResponse<bool>(true, HttpStatusCode.OK, "SUCCESS-Media/CreateMedia"); }
/// <summary> /// This routine is to do post processing of execute extended after calling application /// </summary> /// <param name="processingComponent"></param> /// <param name="arg"></param> protected override void ExecuteExtendedCompleted(IProcessingComponent processingComponent, ProcessingComponentsArgs arg) { base.ExecuteExtendedCompleted(processingComponent, arg); //TODO: after execution completed, inspect xml out for any errors or post processing ServiceMessage msg = new ServiceMessage(arg.XmlOut); if (!DisplayError(msg)) { SetFocus(); base.DisplayMessage(114); // Processing complete. } }
private void ProcessLogon(ServiceMessage serviceMessage) { // Logon attempt var credentials = LogonCredentials.FromBytes(serviceMessage.Data); if (!this.dataContext.ValidateLoginPass(credentials.Login, credentials.Password)) { this.ProcessConnectionInvalidCredentials(); return; } // Check if user with same login is already logged in if (this.server.IsLoggedIn(credentials.Login)) { var existingClient = this.server.GetChatClient(credentials.Login); if (existingClient.PokeForAlive()) { // Client with login <login> still alive -> new login attempt invalid var resp = new ServiceMessageResponse { Message = "This login is already used"}; this.cryptoWrapper.Send(resp.ToBytes()); this.FreeTCPClient(); Log.DebugFormat( "Logon from IP '{0}' failed: User '{1}' already logged on", this.clientIpAddress, credentials.Login); } else { // Old client app which used current login is unresponsive -> dispose of it and add new this.server.RemoveClient(credentials.Login); Log.DebugFormat( "Old client app which used login '{0}' is unresponsive -> dispose of it and add new", credentials.Login); this.server.AddLoggedInUser(credentials.Login, this); } } else { this.server.AddLoggedInUser(credentials.Login, this); this.cryptoWrapper.Send(ServiceMessageResponse.Success.ToBytes()); Log.DebugFormat( "Logon from IP '{0}' success: User '{1}' from IP logged on", this.clientIpAddress, credentials.Login); } this.Login = credentials.Login; }
/// <summary> /// This method highlights the error fields and displays the error message. /// </summary> /// <param name="msg">service message containing the error information</param> /// <returns>bool</returns> private bool DisplayError(ServiceMessage msg) { Error error = null; if (msg.Header.ServiceErrors.Count > 0) { error = msg.Header.ServiceErrors[0]; } else if (msg.Body.Errors.Count > 0) { error = msg.Body.Errors[0]; } if (error == null) return false; base.DisplayDataErrors(msg.Body.Errors); return true; }