internal async Task <HelloResponse> SendHelloAsync()
{
HelloRequest request = new HelloRequest
{
AccountKey = Node.Instance.NodeKey,
AvailableProtocol = 6,
Error = 0,
NodeServers = Node.Instance.NodeServers,
Operation = NetOperationType.Hello
};
byte[] h = Utils.Sha256(Encoding.ASCII.GetBytes(Node.NetParams.GenesisPayload));
request.Block = new Block
{
AccountKey = null,
AvailableProtocol = 0,
BlockNumber = 0,
CompactTarget = 0,
Fee = 0,
Nonce = 0,
TransactionHash = new byte[0],
Payload = new byte[0],
ProofOfWork = new byte[0],
ProtocolVersion = 0,
Reward = 0,
#if PRODUCTION
CheckPointHash = h,
#endif
#if TESTNET
CheckPointHash = new byte[0],
#endif
BlockSignature = 3,
Timestamp = 0
};
request.ProtocolVersion = 6;
request.RequestType = RequestType.Request;
request.ServerPort = ServerPort;
request.Timestamp = DateTime.UtcNow;
request.Version = "2.0.0wN";
request.WorkSum = 0;
using (MemoryStream ms = new MemoryStream())
{
request.SaveToStream(ms);
ms.Flush();
ms.Position = 0;
SendRaw(ms);
}
WaitForData(10000);
using (var responseStream = new MemoryStream())
{
var rp = await ReadResponse(responseStream);
if (rp.Operation == NetOperationType.Hello)
{
HelloResponse response = new HelloResponse(responseStream, rp);
return(response);
}
throw new InvalidDataException($"Not hello {rp.Operation}");
}
}
public void TestHelloResponse1()
{
byte[] input = File.ReadAllBytes("Greeting1.xml");
var response = new HelloResponse(input);
Assert.IsNull(response.Code);
Assert.IsNull(response.Message);
/* TODO: Implement in HelloResponse
* Assert.AreEqual("Example EPP server epp.example.com", response.ServerId);
* Assert.AreEqual("2000-06-08T22:00:00.0Z", response.ServerDate);
* Assert.AreEqual("1.0", response.Version);
* List<string> expectedLanguages = new List<string>() { "en", "fr" };
* CollectionAssert.AreEqual(expectedLanguages.ToArray(), response.Languages.ToArray());
* Assert.IsTrue(response.Languages.Contains("en"));
* Assert.IsTrue(response.Languages.Contains("fr"));
* List<string> expectedObjURI = new List<string>()
* {
* "urn:ietf:params:xml:ns:obj1",
* "urn:ietf:params:xml:ns:obj2",
* "urn:ietf:params:xml:ns:obj3",
* };
* CollectionAssert.AreEqual(expectedObjURI.ToArray(), response.ObjectNamespaces.ToArray());
* // Low priority: DCP, Data Collection Policy
*/
Assert.IsNull(response.ClientTransactionId);
Assert.IsNull(response.ServerTransactionId);
}
protected virtual void HandleResponses(MessageHeader rp, MemoryStream ms)
{
switch (rp.Operation)
{
case NetOperationType.Hello:
try
{
HelloResponse response = new HelloResponse(ms, rp);
Node.Instance.NodeServers.UpdateNodeServers(response.NodeServers);
OnHelloResponse(response);
}
catch (Exception e)
{
Log.Error(e.Message, e);
}
break;
case NetOperationType.Transactions:
BlockResponse transactionBlockResponse = new BlockResponse(ms, rp);
OnGetBlockResponse(transactionBlockResponse);
break;
case NetOperationType.Blocks:
BlockResponse blockResponse = new BlockResponse(ms, rp);
OnGetBlockResponse(blockResponse);
break;
case NetOperationType.CheckPoint:
break;
}
}
public void TestHelloResponse()
{
Exception ex = new Exception("foo");
IDictionary <string, object> serverInfo = new Dictionary <string, object>(1);
serverInfo.Add(HelloResponse.SERVER_START_TIME, DateTimeUtil.GetCurrentUtcTimeMillis());
ConnectorKey key = new ConnectorKey("my bundle", "my version", "my connector");
RemoteConnectorInfoImpl info = new RemoteConnectorInfoImpl();
info.Messages = (new ConnectorMessagesImpl());
info.ConnectorKey = (key);
ConfigurationPropertiesImpl configProperties = new ConfigurationPropertiesImpl();
configProperties.Properties = (new List <ConfigurationPropertyImpl>());
APIConfigurationImpl apiImpl = new APIConfigurationImpl();
apiImpl.ConfigurationProperties = (configProperties);
info.DefaultAPIConfiguration = (apiImpl);
info.ConnectorDisplayNameKey = ("mykey");
info.ConnectorCategoryKey = ("");
HelloResponse v1 = new HelloResponse(ex, serverInfo, CollectionUtil.NewReadOnlyList <ConnectorKey>(key), CollectionUtil.NewReadOnlyList <RemoteConnectorInfoImpl>(info));
HelloResponse v2 = (HelloResponse)CloneObject(v1);
Assert.IsNotNull(v2.Exception);
Assert.IsNotNull(v2.ServerInfo[HelloResponse.SERVER_START_TIME]);
Assert.IsNotNull(v2.ConnectorKeys.First());
Assert.IsNotNull(v2.ConnectorInfos.First());
}
public async Task Name_is_not_null___OK_response()
{
var eventMock = new Mock <IEventDispatcher>(MockBehavior.Strict);
var response = new HelloResponse("test");
eventMock
.Setup(e => e.Get(It.IsAny <HelloQuery>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(response))
.Verifiable();
HttpClient client = this.CreateHttpClient(eventMock);
HttpResponseMessage httpResponse = await client.GetAsync("/api/greeting/hello?name=tester");
Assert.Multiple(async() =>
{
Assert.DoesNotThrow(() => httpResponse.EnsureSuccessStatusCode());
Assert.AreEqual(HttpStatusCode.OK, httpResponse.StatusCode);
StringAssert.StartsWith("application/json", httpResponse.Content.Headers.ContentType.ToString());
HelloResponse actual = await httpResponse.Content.ReadFromJsonAsync <HelloResponse>();
Assert.AreEqual(response.Message, actual.Message);
});
}
/// <summary>
/// Called when the hello response is received.
/// </summary>
/// <param name="response">Data associated with response.</param>
/// <returns>Task.</returns>
protected virtual async Task OnHelloResponseReceived(HelloResponse response)
{
Debug.Assert(response != null && response.Data != null, "Response data is null/missing");
this.log?.Info($"{RecInd} Hello");
this.lastSequence = response.Sequence;
this.HeartbeatInterval = response.Data is null ? -1 : response.Data.HeartbeatInterval;
this.SetHeartbeatInterval(this.HeartbeatInterval);
var ident = new IdentityRequest
{
Data = new IdentityRequest.IdentityData()
{
Compress = false,
LargeThreshold = 250,
Presence = new IdentityRequest.StatusUpdate
{
Afk = false,
Game = null,
Since = null,
Status = "online"
},
Properties = new IdentityRequest.ConnectionProperties
{
Browser = "disco",
Device = "disco",
Os = "windows" // Environment.OSVersion.Platform.ToString()
},
Token = this.Options !.AuthToken
},
public object Any(HelloAuth request)
{
var response = new HelloResponse {
Result = "Hello, " + request.Name
};
return(response);
}
/// <summary>
/// mock的Response操作
/// </summary>
#region
void HelloResponse(IMessage request, RpcResponse callback)
{
HelloRequest requestRpc = (HelloRequest)request;
HelloResponse response = new HelloResponse();
response.Greet = "Mock:" + requestRpc.Content;
callback(response);
}
public override Task <HelloResponse> SayHello(HelloRequest message, ReadOnlySequence <byte> metadata)
{
Console.WriteLine($"received a message -> {message.Name}");
var response = new HelloResponse();
response.Message = "Hello, " + message.Name;
return(Task.FromResult(response));
}
/// <summary>
/// 打招呼
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public ResultObject <HelloResponse> Hello(HelloRequest request)
{
var msg = $"Hello {request.ToUser}, I'm {request.GetClaimValue("userid")}.";
var response = new HelloResponse()
{
Msg = msg
};
return(new ResultObject <HelloResponse>(response));
}
public async Task Test_hello()
{
HelloResponse helloresponse = await deribit.Supporting.Hello(new HelloRequest
{
client_name = "clientname",
client_version = "1",
});
Assert.That(helloresponse.version, Is.Not.Null);
}
public void RPC_TEST()
{
HelloRequest request = new HelloRequest();
request.Content = rpcInput.value;
App.Manager.Network.Request("Hello", request, delegate(IMessage response) {
HelloResponse res = response as HelloResponse;
rpcResponse.text = res.Greet;
App.Manager.Event.Broadcast("_greeting", res.Greet);
});
}
public object Any(Hello request)
{
var dto = new HelloResponse {
Result = "Hello, " + request.Name
};
return(new HttpResult(dto)
{
Headers =
{
{ "Access-Control-Allow-Origin", "*" },
public override Task <HelloResponse> SayHello(HelloRequest request, ServerCallContext context)
{
string resultMessage = $"Hello {request.Name}";
var response = new HelloResponse
{
Message = resultMessage
};
return(Task.FromResult(response));
}
public void Async_Call_HelloWorld_with_Async_ServiceClients_on_UserDefined_Routes(IServiceClient client)
{
HelloResponse response = null;
client.GetAsync <HelloResponse>("/hello/World!",
r => response = r, (r, e) => Assert.Fail("NetworkError"));
Thread.Sleep(TimeSpan.FromSeconds(1));
Assert.That(response.Result, Is.EqualTo("Hello, World!"));
}
public object Any(Hello request)
{
var response = new HelloResponse { Result = "Hello, " + request.Name };
if (Request.Files.Length > 0)
{
response.Result += ".\nFiles: {0}, name: {1}, size: {2} bytes".Fmt(Request.Files.Length, Request.Files[0].FileName, Request.Files[0].ContentLength);
}
return response;
}
public object Execute(Hello request)
{
var dto = new HelloResponse {
Result = "Hello, " + request.Name
};
return(new HttpResult(dto)
{
{ "Access-Control-Allow-Origin", "*" },
{ "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS" },
});
}
public void Receives()
{
IClient client = CreateClient();
HelloResponse response = new HelloResponse("hello");
_runtime.ReadResponse().Returns(JsonConvert.SerializeObject(response));
client.Hello();
_runtime.Received().ReadResponse();
}
public async Task <TResponse> Send <TResponse>(IRequestData <TResponse> request) where TResponse : IResponseData
{
if (_supportHello && request is HelloRequest)
{
IResponseData helloResponse = new HelloResponse();
return(await Task.FromResult((TResponse)helloResponse));
}
var tcp = new TaskCompletionSource <TResponse>();
tcp.SetException(new RequestFailed(new [] { new Error(ErrorCode.Unknown, "Haha lol") }));
return(await tcp.Task);
}
public object Any(Hello request)
{
var response = new HelloResponse {
Result = "Hello, " + request.Name
};
if (Request.Files.Length > 0)
{
response.Result += ".\nFiles: {0}, name: {1}, size: {2} bytes".Fmt(Request.Files.Length, Request.Files[0].FileName, Request.Files[0].ContentLength);
}
return(response);
}
public SubscriberInfo Connect(Stream stream)
{
this.Connector.Connect(stream);
Subscriber localSubscriber = this.Subscription.LocalSubscriber;
HelloResponse response = this.Dialog.SendRequest(new HelloRequest(MessageId.NextId(), localSubscriber));
SubscriberInfo subscriberInfo = new SubscriberInfo(localSubscriber, response.Subscriber);
this.Subscription.Subscribe(subscriberInfo);
return(subscriberInfo);
}
public object Any(Hello request)
{
HelloResponse result = new HelloResponse {
Result = string.Format("Hello, {0}", request.Name)
};
//IAuthSession authSession = this.GetSession();
//if (authSession != null) {
// string displayName = authSession.DisplayName;
// result.Result += string.Format("(or is it {0})", displayName);
//}
Console.WriteLine("Request: " + request.Name);
return(result);
}
public async Task <SubscriberInfo> ConnectAsync(Stream stream, CancellationToken cancellationToken = default)
{
await this.Connector.ConnectAsync(stream, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
Subscriber localSubscriber = this.Subscription.LocalSubscriber;
HelloResponse response = await this.Dialog.SendRequestAsync(new HelloRequest( MessageId.NextId(), localSubscriber ), cancellationToken);
SubscriberInfo subscriberInfo = new SubscriberInfo(localSubscriber, response.Subscriber);
this.Subscription.Subscribe(subscriberInfo);
return(subscriberInfo);
}
private async Task SendHelloAnswer(HelloRequest msg)
{
_gossipNode.AddPeer(msg.Peer);
HelloResponse o = new HelloResponse();
o.Members.Add(_gossipNode.GossipPeer);
o.Members.Concat(_gossipNode.RemotePeers);
o.RemoteEndPoint = _gossipNode.GossipPeer.EndPoint;
o.Id = Guid.NewGuid().ToString();
o.RequestMessageId = msg.Id;
await SendAsync(o, msg.RemoteEndPoint);
}
private void WebService_OnMessageReceive(string message)
{
GatewayResponse response = json.Deserialize <GatewayResponse>(message);
if (response == null)
{
return;
}
switch (response.Op)
{
case Op.Hello:
HelloResponse hello = json.Deserialize <HelloResponse>(message);
heartbeatInterval = hello.D.Heartbeat_Interval;
OnConnected();
break;
case Op.Dispatch:
DispatchResponse dispatch = json.Deserialize <DispatchResponse>(message);
lastReceived = dispatch.S;
switch (dispatch.T)
{
case "READY":
heartbeatTimer = new Timer(
async(_) => await webService.Send(json.Serialize(new HeartbeatMessage()
{
d = lastReceived
})),
null,
0,
heartbeatInterval
);
break;
case "MESSAGE_CREATE":
MessageCreateResponse messageResponse = json.Deserialize <MessageCreateResponse>(message);
OnReceiveMessage(messageResponse.D);
break;
default:
Console.WriteLine(message);
break;
}
break;
default:
Console.WriteLine(message);
break;
}
}
public object Any(HelloAuth request)
{
Debug.Write(HttpContext.Current.User.Identity.Name);
var x = new HelloResponse { Result = "Hello, {0}!".Fmt(request.Name) };
var identity = (ClaimsIdentity)HttpContext.Current.User.Identity;
var claims = identity.Claims;
x.Claims = new List<string>();
foreach (var claim in claims)
{
x.Claims.Add(claim.Type+" : "+claim.Value);
}
return x;
}
protected void Page_Load(object sender, EventArgs e)
{
if (User.Identity.IsAuthenticated)
{
//var claims = _owinContext.Authentication.User.Claims;
//var accessToken = claims.FirstOrDefault(c => c.Type == "access_token");
//accessToken = new System.Security.Claims.Claim("access_token", Guid.NewGuid().ToString());
//var newClaims = new List<Claim>(claims.Where(c => c.Type != "access_token"));
//newClaims.Add(accessToken);
//var claimIdentity = new ClaimsIdentity("Cookies","name","role");
//claimIdentity.AddClaims(newClaims);
//_owinContext.Authentication.SignIn(claimIdentity);
//var name = User.Identity.Name;
//labelName.InnerText = name;
using (HttpClient client = new HttpClient())
{
string apiEndpoint = WebConfigurationManager.AppSettings["MainApiServerEndpoint"];
string accessToken = _owinContext.Authentication.User.Claims.FirstOrDefault(c => c.Type == "access_token").Value;
//test drive renew token
//string accessToken = RenewToken().AccessToken;
client.BaseAddress = new Uri(apiEndpoint);
client.SetBearerToken(accessToken);
HttpResponseMessage response = client.GetAsync("api/hello").Result;
if (response.IsSuccessStatusCode)
{
string json = response.Content.ReadAsStringAsync().Result;
HelloResponse result = JsonConvert.DeserializeObject <HelloResponse>(json);
labelName.InnerText = result.Message;
}
else if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
{
var tokenResponse = RenewToken();
client.SetBearerToken(tokenResponse.AccessToken);
response = client.GetAsync("api/hello").Result;
if (response.IsSuccessStatusCode)
{
string json = response.Content.ReadAsStringAsync().Result;
HelloResponse result = JsonConvert.DeserializeObject <HelloResponse>(json);
labelName.InnerText = result.Message;
}
}
}
}
}
public void TestHello()
{
HelloRequest request = new HelloRequest();
//request.Version = "1.0";
HelloResponse response = client.Execute <HelloResponse>(request);
if (response.IsSuccess())
{
Assert.IsNotNull(response.data);
}
else
{
throw new SystemException(response.msg);
}
}
public async Task Query_given___correct_response()
{
var envMock = new Mock <IWebHostEnvironment>();
var query = new HelloQuery("Dummy");
var sut = new HelloQueryHandler(envMock.Object);
envMock
.Setup(e => e.ApplicationName)
.Returns("Test")
.Verifiable();
HelloResponse response = await sut.Handle(query);
envMock.Verify();
Assert.AreEqual("Hello 'Dummy' from Test", response.Message);
}
public void Hello(ref EndpointReferenceType EndpointReference, string Types, ScopesType Scopes, string XAddrs, uint MetadataVersion, ref System.Xml.XmlElement[] Any, ref System.Xml.XmlAttribute[] AnyAttr)
{
HelloRequest inValue = new HelloRequest();
inValue.EndpointReference = EndpointReference;
inValue.Types = Types;
inValue.Scopes = Scopes;
inValue.XAddrs = XAddrs;
inValue.MetadataVersion = MetadataVersion;
inValue.Any = Any;
inValue.AnyAttr = AnyAttr;
HelloResponse retVal = ((RemoteDiscoveryPort)(this)).Hello(inValue);
EndpointReference = retVal.EndpointReference;
Any = retVal.Any;
AnyAttr = retVal.AnyAttr;
}
public override async Task SayHelloStream(IAsyncStreamReader <HelloRequest> requestStream, IServerStreamWriter <HelloResponse> responseStream, ServerCallContext context)
{
Console.WriteLine("C# service stream request");
while (await requestStream.MoveNext(context.CancellationToken))
{
var req = requestStream.Current;
var resp = new HelloResponse {
Message =
{
"Hello " + req.Name,
"Aloha " + req.Name,
"Howdy " + req.Name
}
};
await responseStream.WriteAsync(resp);
}
}
public object Any(HelloAuth request)
{
Debug.Write(HttpContext.Current.User.Identity.Name);
var x = new HelloResponse {
Result = "Hello, {0}!".Fmt(request.Name)
};
var identity = (ClaimsIdentity)HttpContext.Current.User.Identity;
var claims = identity.Claims;
x.Claims = new List <string>();
foreach (var claim in claims)
{
x.Claims.Add(claim.Type + " : " + claim.Value);
}
return(x);
}
public object Any(Hello request)
{
HelloResponse result = new HelloResponse {Result = string.Format("Hello, {0}", request.Name)};
//IAuthSession authSession = this.GetSession();
//if (authSession != null) {
// string displayName = authSession.DisplayName;
// result.Result += string.Format("(or is it {0})", displayName);
//}
Console.WriteLine("Request: " + request.Name);
return result;
}
public void HelloRpc(Controller controller, HelloRequest request, HelloResponse response)
{
Console.WriteLine("request: " + request.message + " response: " + response.message);
}
private bool ProcessRequest()
{
CultureInfo locale;
try
{
locale = (CultureInfo)_connection.ReadObject();
}
catch (EndOfStreamException)
{
return false;
}
//We can't set this because C# does not like language-neutral
//cultures for CurrentCulture - this tends to blow up
//TODO: think more about this...
//Thread.CurrentThread.CurrentCulture = locale;
Thread.CurrentThread.CurrentUICulture = locale;
GuardedString key = (GuardedString)_connection.ReadObject();
bool authorized;
try
{
authorized = key.VerifyBase64SHA1Hash(_server.KeyHash);
}
finally
{
key.Dispose();
}
Org.IdentityConnectors.Framework.Common.Exceptions.InvalidCredentialException authException = null;
if (!authorized)
{
authException = new Org.IdentityConnectors.Framework.Common.Exceptions.InvalidCredentialException("Remote framework key is invalid");
}
Object requestObject = _connection.ReadObject();
if (requestObject is HelloRequest)
{
if (authException != null)
{
HelloResponse response =
new HelloResponse(authException, null, null, null);
_connection.WriteObject(response);
}
else
{
HelloResponse response =
ProcessHelloRequest((HelloRequest)requestObject);
_connection.WriteObject(response);
}
}
else if (requestObject is OperationRequest)
{
if (authException != null)
{
OperationResponsePart part =
new OperationResponsePart(authException, null);
_connection.WriteObject(part);
}
else
{
OperationRequest opRequest =
(OperationRequest)requestObject;
OperationResponsePart part =
ProcessOperationRequest(opRequest);
_connection.WriteObject(part);
}
}
else if (requestObject is EchoMessage)
{
if (authException != null)
{
//echo message probably doesn't need auth, but
//it couldn't hurt - actually it does for test connection
EchoMessage part =
new EchoMessage(authException, null);
_connection.WriteObject(part);
}
else
{
EchoMessage message = (EchoMessage)requestObject;
Object obj = message.Object;
String xml = message.ObjectXml;
if (xml != null)
{
Console.WriteLine("xml: \n" + xml);
Object xmlClone =
SerializerUtil.DeserializeXmlObject(xml, true);
xml =
SerializerUtil.SerializeXmlObject(xmlClone, true);
}
EchoMessage message2 = new EchoMessage(obj, xml);
_connection.WriteObject(message2);
}
}
else
{
throw new Exception("Unexpected request: " + requestObject);
}
return true;
}
public object Any(HelloAuth request)
{
var response = new HelloResponse { Result = "Hello, " + request.Name };
return response;
}
