private void InitServer()
{
IMqttNetLogger logger = new MqttNetLogger();
serverOptionsBuilder = new MqttServerOptionsBuilder()
.WithDefaultEndpointBoundIPAddress(IPAddress.Parse(ip))
.WithDefaultEndpointPort(port)
.WithDefaultCommunicationTimeout(TimeSpan.FromSeconds(communicationTimeout))
.WithEncryptionSslProtocol(sslProtocols);
// connect verfication
serverOptionsBuilder.WithConnectionValidator(valid =>
{
if (valid.ClientId.Length < 10)
{
valid.ReasonCode = MqttConnectReasonCode.ClientIdentifierNotValid;
return;
}
if (!valid.Username.Equals(this.username))
{
valid.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
return;
}
if (!valid.Password.Equals(password))
{
valid.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
return;
}
valid.ReasonCode = MqttConnectReasonCode.Success;
});
serverOptions = serverOptionsBuilder.Build();
mqttServer = (new MqttFactory()).CreateMqttServer(logger) as MqttServer;
mqttServer.ClientConnectedHandler = new MqttServerClientConnectedHandlerDelegate(e =>
{
ClientIds.Add(e.ClientId);
Logger.Info($"clientID:{e.ClientId} connect success!");
});
mqttServer.ClientDisconnectedHandler = new MqttServerClientDisconnectedHandlerDelegate(e =>
{
ClientIds.RemoveWhere(s => s.Equals(e.ClientId));
Logger.Info($"clientID:{e.ClientId} disconnect!");
});
mqttServer.UseApplicationMessageReceivedHandler(e =>
{
AppMsgReceivedHandler?.Invoke(e.ClientId, e.ApplicationMessage);
});
}
/// <inheritdoc />
public override void OnActionExecuting(ActionExecutingContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (context.ActionDescriptor.FilterDescriptors.Any(x => x.Filter is IgnoreRequestsSignatureValidationAttribute))
{
return;
}
var validationResult = context.HttpContext.GetSignatureValidationResult();
if (validationResult == null || !AcceptedStatus.Contains(validationResult.Status))
{
if (ThrowsOnValidationError)
{
throw new RequestsSignatureValidationException(validationResult);
}
context.Result = new UnauthorizedResult();
return;
}
if (ClientIds != null && ClientIds.Any())
{
if (!ClientIds.Contains(validationResult.ClientId))
{
if (ThrowsOnValidationError)
{
throw new RequestsSignatureValidationException(validationResult);
}
context.Result = new StatusCodeResult(StatusCodes.Status403Forbidden);
return;
}
}
base.OnActionExecuting(context);
}
public bool IsAccepted(ViewData dataEntry)
{
if (ClientIds != null && !ClientIds.Contains(dataEntry.ClientId))
{
return(false);
}
if (Type != null && dataEntry.DataManagerType.TypeId.IndexOf(Type, StringComparison.OrdinalIgnoreCase) == -1)
{
return(false);
}
if (!string.IsNullOrEmpty(SearchText) &&
(dataEntry.EntryName.IndexOf(SearchText, StringComparison.OrdinalIgnoreCase) == -1 ||
dataEntry.DataManagerType.TypeId.IndexOf(SearchText, StringComparison.OrdinalIgnoreCase) == -1))
{
return(false);
}
return(true);
}
/// <summary>
/// Returns whether the license is valid and is valid for the specified <paramref name="clientId" />.
/// </summary>
/// <param name="clientId">The client identifier.</param>
public Result AssertValidLicense(string clientId)
{
Guard.AgainstNullArgument("clientId", clientId);
#if DEBUG
LogTo.Debug("Running in DEBUG mode, not validating the license.");
return(Result.AsSuccess());
#else
if (this._license == null)
{
return(Result.AsError(LicensingMessages.LicenseNotFound));
}
if (ClientIds.Get().Any(f => string.Equals(f, clientId, StringComparison.InvariantCultureIgnoreCase)) == false)
{
return(Result.AsError(LicensingMessages.InvalidClient));
}
List <IValidationFailure> errors = this._license
.Validate().ExpirationDate()
.And().Signature(PublicKey)
.And().AssertThat(LicenseIsValidForCurrentVersion, new LicenseIsInvalidForCurrentVersionValidationFailure())
.And().AssertThat(f => this.LicenseHasClientId(f, clientId), new ClientIdMissingValidationFailure())
.AssertValidLicense()
.ToList();
if (errors.Any())
{
string licenseErrorMessages = this.GetLicenseErrorMessagesForClient(errors);
LogTo.Error("The license is invalid. {0}", licenseErrorMessages);
return(Result.AsError(string.Format(LicensingMessages.LicenseIsInvalid, licenseErrorMessages)));
}
return(Result.AsSuccess());
#endif
}
partial void ProcessEachClientIds(ClientIds notifies);
