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;
}
