public override Task <VersionResponse> GetVersion(VersionRequest request, ServerCallContext context)
{
return(Task.FromResult(new VersionResponse()
{
Message = "CurrentVersion" + request.Version
}));
}
private async Task CallBuiltinVersionServiceCore(JsonServer js, JsonClient jc, ICredentials credentials = null)
{
// event handlers
var connected = 0;
var disconnected = 0;
js.ClientConnected += (s, e) => connected++;
js.ClientDisconnected += (s, e) => disconnected++;
js.UnhandledException += (s, e) => Assert.Fail($"Unhandled server exception: {e.Exception}. Connected: {connected}, disconnected: {disconnected}.");
jc.UnhandledException += (s, e) => Assert.Fail($"Unhandled client exception: {e.Exception}. Connected: {connected}, disconnected: {disconnected}.");
// start json server and connect the client
js.Start();
Assert.IsNull(jc.SessionId);
var sessionId = await jc.ConnectAsync(credentials);
Assert.IsNotNull(jc.SessionId);
Assert.AreEqual(sessionId, jc.SessionId);
// call Version
var msg = new VersionRequest();
var result = await Assert_NotTimedOut(jc.Call(msg), "jc.Call(VersionRequest)");
Assert.NotNull(result);
Assert.AreEqual(nameof(JsonServices), result.ProductName);
Assert.NotNull(result.ProductVersion);
Assert.NotNull(result.EngineVersion);
// make sure all incoming messages are processed
Assert.AreEqual(0, jc.PendingMessages.Count);
}
public void Valid_GetVersion_Request_Should_Send_VersionResponse()
{
var testScheduler = new TestScheduler();
var versionRequest = new VersionRequest();
var protocolMessage =
versionRequest.ToProtocolMessage(PeerIdHelper.GetPeerId("sender"));
var messageStream = MessageStreamHelper.CreateStreamWithMessage(_fakeContext, testScheduler,
protocolMessage
);
var peerSettings = PeerIdHelper.GetPeerId("sender").ToSubstitutedPeerSettings();
var handler = new GetVersionRequestObserver(peerSettings, _logger);
handler.StartObserving(messageStream);
testScheduler.Start();
var receivedCalls = _fakeContext.Channel.ReceivedCalls().ToList();
receivedCalls.Count.Should().Be(1);
var sentResponseDto = (IMessageDto <ProtocolMessage>)receivedCalls.Single().GetArguments().Single();
var versionResponseMessage = sentResponseDto.Content.FromProtocolMessage <VersionResponse>();
versionResponseMessage.Version.Should().Be(NodeUtil.GetVersion());
}
public ServiceResult <VersionModel> Version(VersionRequest model)
{
//var appVersion = new AppVersionComponent().GetLatestByPlatform((byte)model.Platform, (byte)model.App);
var json = RedisHelper.StringGet(4, $"Foundation:Version:{model.App}:{model.Platform}");
if (string.IsNullOrWhiteSpace(json))
{
var version = new AppVersionComponent().GetLatestByPlatform((byte)model.Platform, (byte)model.App);
RedisHelper.StringSet(4, $"Foundation:Version:{model.App}:{model.Platform}",
JsonConvert.SerializeObject(version));
return(new ServiceResult <VersionModel>
{
Data = new VersionModel
{
ForceToUpdate = version.ForceToUpdate,
Url = version.Url,
Version = version.Version
}
});
}
var appVersion = JsonConvert.DeserializeObject <VersionModel>(json);
appVersion.Version1 = appVersion.Version;
appVersion.ForceToUpdate1 = appVersion.ForceToUpdate;
appVersion.Url1 = appVersion.Url;
return(new ServiceResult <VersionModel>
{
Data = appVersion
});
}
public void GetVersionMajorMinor()
{
var versionDetail = new VersionRequest()
{
ProductId = 1,
Major = 8,
Minor = 2
};
var repository = new Mock <IVersionDetailRepository>();
repository.Setup(x => x.GetByProductId(versionDetail.ProductId))
.Returns(VersionDetails
.Where(x => x.Product.Id == versionDetail.ProductId &&
x.Version.Major == versionDetail.Major));
var service = new VersionService(repository.Object);
var version = service.GetVersions(versionDetail);
version.Count().Should().Be(1);
var expectedVersion = new VersionSimple(8, 2, 100, 0);
version.First().Version.Major.Should().Be(expectedVersion.Major);
version.First().Version.Minor.Should().Be(expectedVersion.Minor);
version.First().Version.Build.Should().Be(expectedVersion.Build);
version.First().Version.Revision.Should().Be(expectedVersion.Revision);
}
public override Task <VersionResponse> Version(VersionRequest request, ServerCallContext context)
{
return(Task.FromResult(new VersionResponse()
{
Version = 1
}));
}
private void RespCallback(IAsyncResult asyncResult)
{
try {
VersionRequest request = (VersionRequest)asyncResult.AsyncState;
HttpWebResponse response = (HttpWebResponse)request.request.EndGetResponse(asyncResult);
using (StreamReader reader = new StreamReader(response.GetResponseStream())) {
_siteVersion = new Version(reader.ReadToEnd());
if (_siteVersion > ThisOrSkippedVersion && this.NewVersionAppeared != null)
{
//if (request.AutoUpdate)
if (NewVersionAppeared != null)
{
NewVersionAppeared(this, null);
}
}
else
{
if (NoUpdatesFound != null)
{
NoUpdatesFound(this, null);
}
}
}
} catch (Exception) {
//MessageBox.Show(e.Message);
}
}
public async Task Subscribe_To_Message_Stream_Should_Return_VersionRequest()
{
await _rpcServer.StartAsync();
VersionRequest returnedVersionRequest = null;
var targetVersionRequest = new VersionRequest {
Query = true
};
var protocolMessage =
targetVersionRequest.ToProtocolMessage(_peerId, CorrelationId.GenerateCorrelationId());
var observerDto = new ObserverDto(_channelHandlerContext, protocolMessage);
_rpcServer.MessageStream
.Where(x => x.Payload != null && x.Payload.TypeUrl == typeof(VersionRequest).ShortenedProtoFullName())
.SubscribeOn(_testScheduler)
.Subscribe(request => returnedVersionRequest = request.Payload.FromProtocolMessage <VersionRequest>());
_mockSocketReplySubject.OnNext(observerDto);
_testScheduler.Start();
targetVersionRequest.Should().Be(returnedVersionRequest);
}
public override Task <VersionResponse> Version(VersionRequest request, ServerCallContext context)
{
this.logger.Info($"Connected client {context.Peer}");
return(Task.FromResult(new VersionResponse()
{
Version = 1,
}));
}
public virtual void RenameApplicationVersion(Guid appId, string versionId, VersionRequest request)
{
try {
LuisRepository.RenameApplicationVersion(appId, versionId, request);
} catch (Exception ex) {
Logger.Error("LuisService.RenameApplicationVersion failed", this, ex);
}
}
private void InitiateGame()
{
var client = new IClient(Defaults.GAME_PORT);
var server = new IServer(Bot.managers.StorageManager.Spacemaps[MainController.Instance.MapId].IP, Defaults.GAME_PORT);
server.Connected += (s, e) => MainController.Instance.User = new User(client, server);
server.Connect();
Console.WriteLine("Emulator started");
server.XSocket.Write(VersionRequest.write(2103, "3j064e4jt572hqoqbmti6kahti"));
Console.WriteLine("Keeping client alive, waiting for incoming connection.");
}
public virtual string CloneVersion(Guid appId, string versionId, VersionRequest request)
{
return(PolicyService.ExecuteRetryAndCapture400Errors(
"LuisService.CloneVersion",
ApiKeys.LuisRetryInSeconds,
() =>
{
var result = LuisRepository.CloneVersion(appId, versionId, request);
return result;
},
null));
}
public void VersionRequest_can_propery_parse_RWS_version_number()
{
VersionRequest req = new VersionRequest();
Assert.IsTrue(req.UrlPath().Contains("version"));
IRWSResponse resp = _connection.SendRequest(req);
Assert.IsNotNull(resp);
Assert.IsInstanceOfType(resp, typeof(RWSTextResponse));
Assert.AreEqual(HttpStatusCode.OK, _connection.GetLastResult().StatusCode);
}
public virtual string CloneVersion(Guid appId, string versionId, VersionRequest request)
{
try {
var result = LuisRepository.CloneVersion(appId, versionId, request);
return(result);
} catch (Exception ex) {
Logger.Error("LuisService.CloneVersion failed", this, ex);
}
return(null);
}
public virtual void RenameApplicationVersion(Guid appId, string versionId, VersionRequest request)
{
PolicyService.ExecuteRetryAndCapture400Errors(
"LuisService.RenameApplicationVersion",
ApiKeys.LuisRetryInSeconds,
() =>
{
LuisRepository.RenameApplicationVersion(appId, versionId, request);
return(true);
},
false);
}
public void Throws_Exception_For_Non_IPPN_Message()
{
var rpcMessage = new VersionRequest();
Assert.Throws <ArgumentException>(() =>
{
// ReSharper disable once ObjectCreationAsStatement
new PeerClientMessageDto(rpcMessage,
PeerIdHelper.GetPeerId("sender"),
Substitute.For <ICorrelationId>()
);
});
}
public object Any(VersionRequest request)
{
CheckServerObject();
if (SConfig?.ServerPeerInfo?.Version != null)
{
return(SConfig.ServerPeerInfo.Version.ApiVersion.ToString());
}
else
{
throw new NullReferenceException("Server version object is null, can't respond");
}
}
private void LookForUpdatesThread(object auto)
{
if (ThisOrSkippedVersion != null || !(bool)auto)
{
try {
VersionRequest request = new VersionRequest((HttpWebRequest)WebRequest.Create("http://prac.us.edu.pl/~kansy/lt10v.htm"), (bool)auto);
request.AutoUpdate = (bool)auto;
request.request.BeginGetResponse(RespCallback, request);
} catch (Exception) {
//MessageBox.Show(e.Message);
}
}
}
public void GetVersion()
{
var versionDetail = new VersionRequest()
{
ProductId = 1
};
var repository = new Mock <IVersionDetailRepository>();
repository.Setup(x => x.GetByProductId(versionDetail.ProductId))
.Returns(VersionDetails.Where(x => x.Product.Id == versionDetail.ProductId));
var service = new VersionService(repository.Object);
var version = service.GetVersions(versionDetail);
version.Count().Should().Be(4);
}
public void AddItemToVersion()
{
var versionDetail = new VersionRequest()
{
ProductId = 1,
Major = 8,
Minor = 2
};
var addResult = new VersionDetail
{
Id = 1,
Version = new VersionSimple
{
Major = 8,
Minor = 2,
Build = 101,
Revision = 0
},
CreatedDate = DateTime.Now
};
var repository = new Mock <IVersionDetailRepository>();
repository.Setup(x => x.GetByProductId(versionDetail.ProductId))
.Returns(VersionDetails
.Where(x => x.Product.Id == versionDetail.ProductId &&
x.Version.Major == versionDetail.Major));
repository.Setup(x => x.Add(It.IsAny <VersionDetail>()))
.Returns(addResult);
var service = new VersionService(repository.Object);
var version = service.IncrementVersion(versionDetail);
var expectedVersion = new VersionSimple(8, 2, 101, 0);
version.Version.Major.Should().Be(expectedVersion.Major);
version.Version.Minor.Should().Be(expectedVersion.Minor);
version.Version.Build.Should().Be(expectedVersion.Build);
version.Version.Revision.Should().Be(expectedVersion.Revision);
}
public static void Execute(byte[] bytes, GameClient client)
{
var parser = new ByteParser(bytes);
if (parser.CMD_ID == VersionRequest.ID)
{
var read = new VersionRequest();
read.readCommand(bytes);
if (QueryManager.CheckSessionId(read.major, read.minor))
{
new VersionRequestHandler(client, read.major);
}
return;
}
var gameSession = GameManager.GetGameSession(client.UserId);
if (gameSession == null)
{
return;
}
if (Commands.ContainsKey(parser.CMD_ID))
{
Commands[parser.CMD_ID].execute(gameSession, bytes);
gameSession.LastActiveTime = DateTime.Now;
}
else
{
if (!IgnoredCommands.Contains(parser.CMD_ID))
{
Out.WriteLine("Unknown command ID: " + parser.CMD_ID);
}
}
}
public void RequestVersion()
{
VersionRequest req = new VersionRequest(_occupantJID);
_sm.BeginSend(req, new AsyncCallback(VersionResponseCallback));
}
public void VersionRequest_can_properly_construct_a_url()
{
var request = new VersionRequest();
Assert.AreEqual("version", request.UrlPath());
}
private IRawConvertible HandleVersionRequest(byte[] rawData, IO_CTL_XFER_MESSAGE request)
{
var _ = new VersionRequest(rawData); // validate request data;
return(new VersionResponse("U2F_V2"));
}
