public override async ValueTask Handle(P00ConnectionHandshake packet) { ProtocolOptions config = options.Value; var response = Packets.New <P01ConnectionResponse>(); ProtocolOptions.Platform platform = config.Platforms.SingleOrDefault(p => p.Name == packet.ApplicationIdentifier); if (platform == null) { throw new ProtocolException($"Unsupported client {packet.ApplicationIdentifier}"); } response.LatestVersion = platform.VersionName; response.LatestVersionCode = platform.VersionCode; if (packet.ProtocolVersion != config.ProtocolVersion || packet.VersionCode < platform.ForceUpdateThreshold) { response.ConnectionState = ConnectionState.MustUpgrade; } else if (packet.VersionCode < platform.RecommendUpdateThreshold) { response.ConnectionState = ConnectionState.CanUpgrade; } else { response.ConnectionState = ConnectionState.Valid; } Client.Initialize(packet.ApplicationIdentifier, packet.VersionCode); await Client.Send(response).ConfigureAwait(false); }
private Connection CreateConnection(ProtocolOptions protocolOptions = null, SocketOptions socketOptions = null, PoolingOptions poolingOptions = null) { if (socketOptions == null) { socketOptions = new SocketOptions(); } if (protocolOptions == null) { protocolOptions = new ProtocolOptions(); } var config = new Configuration( new Cassandra.Policies(), protocolOptions, poolingOptions, socketOptions, new ClientOptions(false, 20000, null), NoneAuthProvider.Instance, null, new QueryOptions(), new DefaultAddressTranslator(), new StartupOptionsFactory(), new SessionFactoryBuilder(), new Dictionary <string, IExecutionProfile>(), new RequestOptionsMapper(), null, null); return(CreateConnection(GetProtocolVersion(), config)); }
public void Get_NotFound(GetOperation operation) { // Arrange var options = new ProtocolOptions(); var protocol = new DefaultProtocol(m_mockFactory.Object, options); var datakey = new DataKey <int>("Key1"); var key = new byte[] { }; ValuePacket packet = null; m_mockEncoder.Setup(encoder => encoder.GetBytes("Key1")).Returns(key); m_mockCommandWriter.Setup(writer => writer.Get(operation, key)); m_mockFactory.Setup(factory => factory.Context(key)) .Returns <byte[]>(state => (Action2 <IClientConnection, object> action) => { action(m_mockClientConnection.Object, state); return(true); }); m_mockClientConnection.SetupGet(connection => connection.Writer).Returns(m_mockBinaryWriter.Object); m_mockPacketBuilder.Setup(builder => builder.WriteTo(m_mockBinaryWriter.Object)).Returns(0); m_mockClientConnection.SetupGet(connection => connection.Reader).Returns(m_mockBinaryReader.Object); m_mockFactory.Setup(factory => factory.CreatePacketParser(m_mockBinaryReader.Object, It.IsAny <Buffer <byte> >())).Returns(m_mockPacketParser.Object); m_mockFactory.Setup(factory => factory.CreateCommandReader(m_mockPacketParser.Object)).Returns(m_mockCommandReader.Object); m_mockCommandReader.Setup(reader => reader.ReadValue(operation == GetOperation.Gets)).Returns(packet); // Act var result = protocol.Get(operation, datakey); // Assert Assert.True(result); Assert.False(datakey.HasValue); }
private IEndPointResolver Create() { var protocolOptions = new ProtocolOptions( EndPointResolverTests.Port, new SSLOptions().SetHostNameResolver(addr => addr.ToString())); return(new EndPointResolver(new ServerNameResolver(protocolOptions))); }
public Uri GetAbsoluteUri( Uri uriFromCaller, ProtocolOptions protocol) { // you can turn off SSL when testing if (ProtocolOptions.Https == protocol && !SslIsEnabledInConfig()) { protocol = ProtocolOptions.Http; } // deal with ~ (ASP.NET "AppRelative" paths) if (!uriFromCaller.IsAbsoluteUri) { uriFromCaller = Application .ResolvePossibleAppRelativeUri(uriFromCaller); } if (uriFromCaller.IsAbsoluteUri) { UriBuilder builder = new UriBuilder( SchemeFor(protocol), uriFromCaller.Host); PreservePortIfPossible(builder, uriFromCaller); builder.Path = uriFromCaller.GetComponents( UriComponents.Path, UriFormat.Unescaped); // UriBuilder.Query unescapes escaped query strings, // which hoses me for stuff like ReturnUrl // so I'm doing that part manually // builder.Query = uriFromCaller.GetComponents( // UriComponents.Query, UriFormat.UriEscaped); string query = uriFromCaller.GetComponents( UriComponents.Query, UriFormat.UriEscaped); if (query.Length > 0) { string uriWithoutQuery = builder.Uri.AbsoluteUri; string absoluteUri = string.Format("{0}?{1}", uriWithoutQuery, query); return(new Uri(absoluteUri, UriKind.Absolute)); } else { return(builder.Uri); } } else // relative URI { Uri currentRequestUri = Application.CurrentRequestUri; UriBuilder builder = new UriBuilder( SchemeFor(protocol), currentRequestUri.Host); PreservePortIfPossible(builder, currentRequestUri); builder.Path = currentRequestUri.GetComponents( UriComponents.Path, UriFormat.Unescaped); return(new Uri(builder.Uri, uriFromCaller)); } }
public void GetMany(GetOperation operation) { // Arrange var options = new ProtocolOptions(); var protocol = new DefaultProtocol(m_mockFactory.Object, options); var datakey1 = new DataKey <int>("Key1"); var datakey2 = new DataKey <bool>("Key2"); var key1 = new byte[] { 1 }; var key2 = new byte[] { 2 }; byte[][] keys = null; var packet = new ValuePacket() { Flags = 101, Key = key1, Value = new ArraySegment <byte>(new byte[] { }), Version = 245 }; m_mockEncoder.Setup(encoder => encoder.GetBytes("Key1")).Returns(key1); m_mockEncoder.Setup(encoder => encoder.GetBytes("Key2")).Returns(key2); m_mockFactory.Setup(factory => factory.Context(It.IsAny <byte[][]>())) .Returns <byte[][]>(state => (Action2 <IClientConnection, object> action) => { keys = (byte[][])state; action(m_mockClientConnection.Object, state); return(true); }); m_mockCommandWriter.Setup(writer => writer.GetMany(operation, It.IsAny <byte[][]>())); m_mockClientConnection.SetupGet(connection => connection.Writer).Returns(m_mockBinaryWriter.Object); m_mockPacketBuilder.Setup(builder => builder.WriteTo(m_mockBinaryWriter.Object)).Returns(0); m_mockClientConnection.SetupGet(connection => connection.Reader).Returns(m_mockBinaryReader.Object); m_mockFactory.Setup(factory => factory.CreatePacketParser(m_mockBinaryReader.Object, It.IsAny <Buffer <byte> >())).Returns(m_mockPacketParser.Object); m_mockFactory.Setup(factory => factory.CreateCommandReader(m_mockPacketParser.Object)).Returns(m_mockCommandReader.Object); m_mockCommandReader.Setup(reader => reader.ReadValue(operation == GetOperation.Gets)).Returns(() => { var p = packet; if (packet != null) { packet = null; } return(p); }); m_mockObjectFormatter.Setup(formatter => formatter.Deserialize <int>(packet.Value, packet.Flags)).Returns(507); // Act var result = protocol.GetMany(operation, new DataKey[] { datakey1, datakey2 }); // Assert Assert.True(result); Assert.True(datakey1.HasValue); Assert.Equal(245, datakey1.Version); Assert.Equal(507, datakey1.Value); Assert.False(datakey2.HasValue); }
private static ProtocolOptions SwitchPropertiesIfNotTheSameType(ProtocolOptions currentOptions, IConnectionPlugin plugin) { // prevent to reset properties if (currentOptions == null || currentOptions.GetType() != plugin.GetOptionsType()) { return(plugin.CreateOptions()); } return(currentOptions); }
public void Store(StoreOperation operation, string optionsString, bool connectSucceed, bool storeSucceed) { // Arrange var options = new ProtocolOptions(optionsString); var protocol = new DefaultProtocol(m_mockFactory.Object, options); var datakey = new DataKey <int>("Key1") { Value = 12345, Version = 556 }; int flags = 10101; var key = new byte[] { }; var value = new ArraySegment <byte>(new byte[] { }); StorePacket packet = null; m_mockObjectFormatter.Setup(formatter => formatter.Serialize <int>(12345, out flags)).Returns(value); m_mockEncoder.Setup(encoder => encoder.GetBytes("Key1")).Returns(key); m_mockCommandWriter.Setup(writer => writer.Store(It.IsAny <StorePacket>(), options.NoReply)) .Callback <StorePacket, bool>((p, nr) => packet = p); m_mockFactory.Setup(factory => factory.Context(key)) .Returns <byte[]>(state => (Action2 <IClientConnection, object> action) => { if (connectSucceed) { action(m_mockClientConnection.Object, state); } return(connectSucceed); }); if (connectSucceed) { m_mockClientConnection.SetupGet(connection => connection.Writer).Returns(m_mockBinaryWriter.Object); m_mockPacketBuilder.Setup(builder => builder.WriteTo(m_mockBinaryWriter.Object)).Returns(0); if (!options.NoReply) { m_mockClientConnection.SetupGet(connection => connection.Reader).Returns(m_mockBinaryReader.Object); m_mockFactory.Setup(factory => factory.CreatePacketParser(m_mockBinaryReader.Object, It.IsAny <Buffer <byte> >())).Returns(m_mockPacketParser.Object); m_mockFactory.Setup(factory => factory.CreateCommandReader(m_mockPacketParser.Object)).Returns(m_mockCommandReader.Object); m_mockCommandReader.Setup(reader => reader.ReadStored()).Returns(storeSucceed); } } // Act var result = protocol.Store(operation, datakey, 100); // Assert Assert.Equal(connectSucceed && (options.NoReply || storeSucceed), result); Assert.NotNull(packet); Assert.Equal(100, packet.Expires); Assert.Equal(flags, packet.Flags); Assert.Equal(key, packet.Key); Assert.Equal(operation, packet.Operation); Assert.Equal(value, packet.Value); Assert.Equal(556, packet.Version); }
public HostnameContactPoint( IDnsResolver dnsResolver, ProtocolOptions protocolOptions, IServerNameResolver serverNameResolver, bool keepContactPointsUnresolved, string hostname) { _dns = dnsResolver ?? throw new ArgumentNullException(nameof(dnsResolver)); _protocolOptions = protocolOptions ?? throw new ArgumentNullException(nameof(protocolOptions)); _serverNameResolver = serverNameResolver ?? throw new ArgumentNullException(nameof(serverNameResolver)); _keepContactPointsUnresolved = keepContactPointsUnresolved; _hostname = hostname ?? throw new ArgumentNullException(nameof(hostname)); }
internal Configuration(Policies policies, ProtocolOptions protocolOptions, PoolingOptions poolingOptions, SocketOptions socketOptions, ClientOptions clientOptions, IAuthInfoProvider authProvider) { this._policies = policies; this._protocolOptions = protocolOptions; this._poolingOptions = poolingOptions; this._socketOptions = socketOptions; this._clientOptions = clientOptions; this._authProvider = authProvider; }
protected override void SaveTo(ProtocolOptions protocolOptions) { var sshOptions = protocolOptions as SshOptions; base.SaveTo(sshOptions); if (null != sshOptions) { sshOptions.X11Forwarding = this.checkBoxX11Forwarding.Checked; sshOptions.EnableCompression = this.checkBoxCompression.Checked; sshOptions.EnablePagentForwarding = this.checkBoxEnablePagentForwarding.Checked; sshOptions.EnablePagentAuthentication = this.checkBoxEnablePagentAuthentication.Checked; sshOptions.SshVersion = (SshVersion)Enum.Parse(typeof(SshVersion), cmbSshVersion.SelectedValue.ToString()); } }
public Configuration(Policies policies, ProtocolOptions protocolOptions, PoolingOptions poolingOptions, SocketOptions socketOptions, ClientOptions clientOptions, IAuthInfoProvider authProvider, bool metricsEnabled) { this._policies = policies; this._protocolOptions = protocolOptions; this._poolingOptions = poolingOptions; this._socketOptions = socketOptions; this._clientOptions = clientOptions; this._authProvider = authProvider; this._metricsEnabled = metricsEnabled; }
public IReadOnlyDictionary <string, string> CreateStartupOptions(ProtocolOptions options) { var startupOptions = new Dictionary <string, string> { { StartupOptionsFactory.CqlVersionOption, StartupOptionsFactory.CqlVersion } }; string compressionName = null; switch (options.Compression) { case CompressionType.LZ4: compressionName = StartupOptionsFactory.Lz4Compression; break; case CompressionType.Snappy: compressionName = StartupOptionsFactory.SnappyCompression; break; } if (compressionName != null) { startupOptions.Add(StartupOptionsFactory.CompressionOption, compressionName); } if (options.NoCompact) { startupOptions.Add(StartupOptionsFactory.NoCompactOption, "true"); } startupOptions.Add(StartupOptionsFactory.DriverNameOption, AssemblyHelpers.GetAssemblyTitle(typeof(StartupOptionsFactory))); startupOptions.Add( StartupOptionsFactory.DriverVersionOption, AssemblyHelpers.GetAssemblyInformationalVersion(typeof(StartupOptionsFactory))); if (_appName != null) { startupOptions[StartupOptionsFactory.ApplicationNameOption] = _appName; } if (_appVersion != null) { startupOptions[StartupOptionsFactory.ApplicationVersionOption] = _appVersion; } startupOptions[StartupOptionsFactory.ClientIdOption] = _clusterId.ToString(); return(startupOptions); }
private void CreateSession(VirtualSocket socket) { try { Console.WriteLine("New connection"); var options = new ProtocolOptions(); ProtocolSession session = new ProtocolSession(socket, options); session.OnStreamOpened += session_OnStreamOpened; session.OnError += session_OnError; session.Open(); } catch (Exception e) { Console.WriteLine(e.Message); } }
internal Configuration(Policies policies, ProtocolOptions protocolOptions, PoolingOptions poolingOptions, SocketOptions socketOptions, ClientOptions clientOptions, IAuthProvider authProvider, IAuthInfoProvider authInfoProvider, QueryOptions queryOptions) { _policies = policies; _protocolOptions = protocolOptions; _poolingOptions = poolingOptions; _socketOptions = socketOptions; _clientOptions = clientOptions; _authProvider = authProvider; _authInfoProvider = authInfoProvider; _queryOptions = queryOptions; }
/// <summary> /// Processes the specified headers. /// </summary> /// <param name="headers">The headers.</param> /// <param name="type">The type.</param> /// <param name="options">Options.</param> /// <param name="flags">Flags.</param> public void Process(ref byte[] headers, DirectionProcessType type, ProtocolOptions options, int flags) { if (!options.UseCompression) { return; } byte[] result = null; if (type == DirectionProcessType.Inbound) { Decompress(headers, out result); } else { Compress(headers, out result); } headers = result; }
private static string SchemeFor(ProtocolOptions protocol) { return ProtocolOptions.Https == protocol ? Uri.UriSchemeHttps : Uri.UriSchemeHttp; }
public Uri GetAbsoluteUri(Uri uriFromCaller, ProtocolOptions protocol) { // you can turn off SSL when testing if (ProtocolOptions.Https == protocol && !SslIsEnabledInConfig()) protocol = ProtocolOptions.Http; // deal with ~ (ASP.NET "AppRelative" paths) if (!uriFromCaller.IsAbsoluteUri) uriFromCaller = Application.ResolvePossibleAppRelativeUri(uriFromCaller); if (uriFromCaller.IsAbsoluteUri) { UriBuilder builder = new UriBuilder(SchemeFor(protocol), uriFromCaller.Host); PreservePortIfPossible(builder, uriFromCaller); builder.Path = uriFromCaller.GetComponents(UriComponents.Path, UriFormat.Unescaped); // UriBuilder.Query unescapes escaped query strings, // which hoses me for stuff like ReturnUrl // so I'm doing that part manually // builder.Query = uriFromCaller.GetComponents( // UriComponents.Query, UriFormat.UriEscaped); string query = uriFromCaller.GetComponents(UriComponents.Query, UriFormat.UriEscaped); if (query.Length > 0) { string uriWithoutQuery = builder.Uri.AbsoluteUri; string absoluteUri = string.Format("{0}?{1}", uriWithoutQuery, query); return new Uri(absoluteUri, UriKind.Absolute); } else return builder.Uri; } else { // relative URI Uri currentRequestUri = Application.CurrentRequestUri; UriBuilder builder = new UriBuilder(SchemeFor(protocol), currentRequestUri.Host); PreservePortIfPossible(builder, currentRequestUri); builder.Path = currentRequestUri.GetComponents( UriComponents.Path, UriFormat.Unescaped); return new Uri(builder.Uri, uriFromCaller); } }
/// <summary> /// Establishes a connection (using a specific resource manager context) between the calling application and a smart card contained by a specific reader. If no card exists in the specified reader, an error is returned. /// </summary> /// <param name="readerName">The name of the reader that contains the target card.</param> /// <param name="shareMode">A flag that indicates whether other applications may form connections to the card.</param> /// <param name="preferredProtocols">A bitmask of acceptable protocols for the connection. Possible values may be combined with the OR operation.</param> public void Connect(string readerName, ShareModeOptions shareMode, ProtocolOptions preferredProtocols) { if (_hContext == IntPtr.Zero) throw new SCardException("No card reader context established. Must call SCard.EstablishContext() first."); if (_hCard != IntPtr.Zero) throw new SCardException("Already connected to card. Must call SCard.Disconnect() first."); IntPtr hCard = IntPtr.Zero; int rtn = SCardDll.SCardConnectA(_hContext, readerName, (UInt32)shareMode, (UInt32)preferredProtocols, ref hCard, ref _protocol); EvalReturnCode(rtn); _hCard = hCard; }