public SuperSocketService(IServiceProvider serviceProvider, IOptions <ServerOptions> serverOptions, ILoggerFactory loggerFactory, IChannelCreatorFactory channelCreatorFactory)
{
_serverOptions = serverOptions;
Name = serverOptions.Value.Name;
_serviceProvider = serviceProvider;
_pipelineFilterFactory = GetPipelineFilterFactory();
_serverOptions = serverOptions;
_loggerFactory = loggerFactory;
_logger = _loggerFactory.CreateLogger("SuperSocketService");
_channelCreatorFactory = channelCreatorFactory;
_packageHandler = serviceProvider.GetService <IPackageHandler <TReceivePackageInfo> >();
_errorHandler = serviceProvider.GetService <Func <IAppSession, PackageHandlingException <TReceivePackageInfo>, ValueTask <bool> > >();
_sessionHandlers = serviceProvider.GetService <SessionHandlers>();
if (_errorHandler == null)
{
_errorHandler = OnSessionErrorAsync;
}
// initialize session factory
_sessionFactory = serviceProvider.GetService <ISessionFactory>();
if (_sessionFactory == null)
{
_sessionFactory = new DefaultSessionFactory();
}
InitializeMiddlewares();
}
public SuperSocketService(IServiceProvider serviceProvider, IOptions <ServerOptions> serverOptions, IChannelCreatorFactory channelCreatorFactory)
{
var serverOptionsValue = IocUnity.Get <ServerOptions>();
_serverOptions = new ServerConfigOptions <ServerOptions>(serverOptionsValue);
//_serverOptions = serverOptions;
Name = serverOptions.Value.Name;
_serviceProvider = serviceProvider;
_pipelineFilterFactory = GetPipelineFilterFactory();
_channelCreatorFactory = channelCreatorFactory;
_packageHandler = serviceProvider.GetService <IPackageHandler <TSessionData, TReceivePackageInfo> >();
_errorHandler = serviceProvider.GetService <Func <IAppSession <TSessionData>, PackageHandlingException <TReceivePackageInfo>, ValueTask <bool> > >();
_sessionHandlers = serviceProvider.GetService <SessionHandlers <TSessionData> >();
if (_errorHandler == null)
{
_errorHandler = OnSessionErrorAsync;
}
// initialize session factory
_sessionFactory = serviceProvider.GetService <ISessionFactory <TSessionData> >();
if (_sessionFactory == null)
{
_sessionFactory = new DefaultSessionFactory <TSessionData>();
}
InitializeMiddlewares();
}
private async Task <List <GitChange> > GetChanges(Guid repoId, IPackageHandler handler, string packageVersion, GitVersionDescriptor versionRef, IEnumerable <GitItem> items)
{
var changes = new List <GitChange>();
foreach (var item in items)
{
var shouldUpdate = await handler.ShouldUpdate(item.Path).ConfigureAwait(false);
if (shouldUpdate)
{
var itemRef = await _gitClient.GetItemContentAsync(repoId, item.Path, includeContent : true, versionDescriptor : versionRef).ConfigureAwait(false);
var oldContent = await itemRef.GetContent().ConfigureAwait(false);
var newContent = await handler.Update(oldContent, packageVersion).ConfigureAwait(false);
if (!string.Equals(oldContent, newContent))
{
changes.Add(CreateChange(item.Path, newContent));
Log($"Item content of {item.Path} received and changed.");
}
}
}
return(changes);
}
public WebSocketPackageHandler(IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
_websocketCommandMiddleware = serviceProvider
.GetServices <IMiddleware>()
.OfType <IWebSocketCommandMiddleware>()
.FirstOrDefault() as IPackageHandler <WebSocketPackage>;
}
public static IRequestHandler GetRequestHandler(IPackageHandler packageHandler)
{
if (IRequestHandler == null)
return new RequestHandler(packageHandler);
IRequestHandler.Init(packageHandler);
return IRequestHandler;
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultPipelineProcessor{TPackageInfo}"/> class.
/// </summary>
/// <param name="packageHandler">The package handler.</param>
/// <param name="receiveFilter">The initializing receive filter.</param>
/// <param name="maxPackageLength">The max package size.</param>
/// <param name="bufferRecycler">The buffer recycler.</param>
public DefaultPipelineProcessor(IPackageHandler <TPackageInfo> packageHandler, IReceiveFilter <TPackageInfo> receiveFilter, int maxPackageLength = 0, IBufferRecycler bufferRecycler = null)
{
m_PackageHandler = packageHandler;
m_ReceiveFilter = receiveFilter;
m_BufferRecycler = bufferRecycler ?? s_NullBufferRecycler;
m_ReceiveCache = new BufferList();
m_MaxPackageLength = maxPackageLength;
}
public CommandSubProtocolHandler(string name, IServiceProvider serviceProvider, IOptions <CommandOptions> commandOptions, IPackageMapper <WebSocketPackage, TPackageInfo> mapper)
: base(name)
{
var keyType = CommandMiddlewareExtensions.GetKeyType <TPackageInfo>();
var commandMiddlewareType = typeof(WebSocketCommandMiddleware <,>).MakeGenericType(keyType, typeof(TPackageInfo));
_commandMiddleware = Activator.CreateInstance(commandMiddlewareType, serviceProvider, commandOptions, mapper) as IPackageHandler <WebSocketPackage>;
}
private void InitializeMiddlewares()
{
_middlewares = _serviceProvider.GetServices <IMiddleware>().ToArray();
if (_packageHandler == null)
{
_packageHandler = _middlewares.OfType <IPackageHandler <TReceivePackageInfo> >().FirstOrDefault();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BasePackageHandler"/> class.
/// </summary>
/// <param name="successor">The successor</param>
protected BasePackageHandler(IPackageHandler successor)
{
this.Successor = successor ?? throw new ArgumentNullException(nameof(successor));
if (successor.Package == null)
{
throw new ArgumentException("successor.Package must not be null");
}
this.Package = this.Successor.Package;
}
public WebSocketPackageHandler(IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
_websocketCommandMiddleware = serviceProvider
.GetService <IWebSocketCommandMiddleware>() as IPackageHandler <WebSocketPackage>;
_packageHandlerDelegate = serviceProvider.GetService <Func <WebSocketSession, WebSocketPackage, Task> >();
_subProtocolSelector = serviceProvider.GetService <ISubProtocolSelector>();
}
public static IRequestHandler GetRequestHandler(IPackageHandler packageHandler)
{
if (IRequestHandler == null)
{
return(new RequestHandler(packageHandler));
}
IRequestHandler.Init(packageHandler);
return(IRequestHandler);
}
/// <summary>
/// Initializes a new instance of the <see cref="RepositoryManager" /> class.
/// </summary>
/// <param name="repositoryDataAccess">The repository data access.</param>
/// <param name="packageValidator">A validation engine to validate the package.</param>
/// <param name="handler">A handler that creates the arelda metadata XML</param>
/// <param name="parameterHelper">Class to read settings parameters</param>
public RepositoryManager(IRepositoryDataAccess repositoryDataAccess, IPackageValidator packageValidator, IPackageHandler handler,
IParameterHelper parameterHelper, IBus bus)
{
this.repositoryDataAccess = repositoryDataAccess;
this.packageValidator = packageValidator;
this.handler = handler;
this.bus = bus;
syncSettings = parameterHelper.GetSetting <RepositorySyncSettings>();
ignoredFilenameRegex = syncSettings.IgnorierteDateinamenRegex.Split('\n').Select(s => s.Trim()).ToList();
}
public WebSocketPackageHandler(IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
_websocketCommandMiddleware = serviceProvider
.GetServices <IMiddleware>()
.OfType <IWebSocketCommandMiddleware>()
.FirstOrDefault() as IPackageHandler <WebSocketPackage>;
_packageHandlerDelegate = serviceProvider.GetService <Func <WebSocketSession, WebSocketPackage, Task> >();
}
public WebSocketPackageHandler(IServiceProvider serviceProvider, ILoggerFactory loggerFactory, IOptions <HandshakeOptions> handshakeOptions)
{
_serviceProvider = serviceProvider;
_websocketCommandMiddleware = serviceProvider
.GetService <IWebSocketCommandMiddleware>() as IPackageHandler <WebSocketPackage>;
_subProtocolHandlers = serviceProvider.GetServices <ISubProtocolHandler>().ToDictionary(h => h.Name, StringComparer.OrdinalIgnoreCase);
_packageHandlerDelegate = serviceProvider.GetService <Func <WebSocketSession, WebSocketPackage, ValueTask> >();
_logger = loggerFactory.CreateLogger <WebSocketPackageHandler>();
_handshakeOptions = handshakeOptions.Value;
}
public WebSocketPackageHandler(IServiceProvider serviceProvider, ILoggerFactory loggerFactory, IOptions <HandshakeOptions> handshakeOptions)
{
_serviceProvider = serviceProvider;
_websocketCommandMiddleware = serviceProvider
.GetService <IWebSocketCommandMiddleware>() as IPackageHandler <WebSocketPackage>;
_packageHandlerDelegate = serviceProvider.GetService <Func <WebSocketSession, WebSocketPackage, Task> >();
_subProtocolSelector = serviceProvider.GetService <ISubProtocolSelector>();
_logger = loggerFactory.CreateLogger <WebSocketPackageHandler>();
_handshakeOptions = handshakeOptions.Value;
}
private void InitializeMiddlewares()
{
_middlewares = _serviceProvider.GetServices <IMiddleware>().ToArray();
foreach (var m in _middlewares)
{
m.Register(this);
}
if (_packageHandler == null)
{
_packageHandler = _middlewares.OfType <IPackageHandler <TReceivePackageInfo> >().FirstOrDefault();
}
}
public void HandlerPackage(JSNPackageIn pkg)
{
if (pkg == null)
{
log.Error("Package can not null!");
return;
}
int code = pkg.Code;
IPackageHandler handler = null;
if (m_packagesHandlers.ContainsKey(code))
{
handler = m_packagesHandlers[code];
}
else
{
log.ErrorFormat("Receive package's code is not exists! Code: {0}", code);
log.Error(Marshal.ToHexDump(string.Format("Code: {0}", code), pkg.Buffer));
}
if (handler == null)
{
return;
}
long timeUsed = Environment.TickCount;
try
{
handler.HandlePacket(m_client, pkg);
}
catch (Exception ex)
{
string ep = m_client.Socket.RemoteEndPoint;
log.ErrorFormat("Error while processing package (handler={0} RemoteEndPoint={1})", handler.GetType().FullName, ep);
log.Error("Handle package error!", ex);
}
timeUsed = Environment.TickCount - timeUsed;
log.InfoFormat("Package process time: {0}ms", timeUsed);
if (timeUsed > 1000)
{
string source = m_client.Socket.RemoteEndPoint;
log.WarnFormat("({0}) Handle package thread {1} {2} took {3}ms!", source, System.Threading.Thread.CurrentThread.ManagedThreadId, handler, timeUsed);
}
}
private void InitializeMiddlewares()
{
_middlewares = _serviceProvider.GetServices <IMiddleware>()
.OrderBy(m => m.Order)
.ToArray();
foreach (var m in _middlewares)
{
m.Start(this);
}
if (_packageHandler == null)
{
_packageHandler = _middlewares.OfType <IPackageHandler <TSessionData, TReceivePackageInfo> >().FirstOrDefault();
}
}
public static void Teardown()
{
_iPackageHandler = null;
_iRequestHandler = null;
_iAttributionHandler = null;
_logger = null;
_httpMessageHandler?.Dispose();
_httpMessageHandler = null;
_packageHandlerBackoffStrategy = null;
_sdkClickHandlerBackoffStrategy = null;
_timerInterval = DefaultTimerInterval;
_timerStart = DefaultTimerStart;
_sessionInterval = DefaultSessionInterval;
_subsessionInterval = DefaultSubsessionInterval;
_maxDelayStart = DefaultMaxDelayStart;
_baseUrl = Constants.BASE_URL;
}
public SuperSocketService(IServiceProvider serviceProvider, IOptions <ServerOptions> serverOptions, ILoggerFactory loggerFactory, IChannelCreatorFactory channelCreatorFactory)
{
_serverOptions = serverOptions;
Name = serverOptions.Value.Name;
_serviceProvider = serviceProvider;
_pipelineFilterFactory = GetPipelineFilterFactory();
_serverOptions = serverOptions;
_loggerFactory = loggerFactory;
_logger = _loggerFactory.CreateLogger("SuperSocketService");
_channelCreatorFactory = channelCreatorFactory;
_packageHandler = serviceProvider.GetService <IPackageHandler <TReceivePackageInfo> >();
// initialize session factory
_sessionFactory = serviceProvider.GetService <ISessionFactory>();
if (_sessionFactory == null)
{
_sessionFactory = new DefaultSessionFactory();
}
InitializeMiddlewares();
}
public async Task <List <int> > UpdateReferencesAndCreatePullRequests(IPackageHandler handler, string packageVersion)
{
var results = new List <int>();
var allRepositories = await _gitClient.GetRepositoriesAsync(_projectId).ConfigureAwait(false);
Log($"Received repository list: {string.Join(", ", allRepositories.Select(m => m.Name))}.");
foreach (var repo in allRepositories)
{
// New repositories have no branches yet -> no default branch
if (repo.DefaultBranch != null)
{
var branchName = GetBranchName(repo.DefaultBranch);
var pr = await UpdateReferencesAndCreatePullRequest(repo.Name, branchName, handler, packageVersion).ConfigureAwait(false);
if (pr.HasValue)
{
results.Add(pr.Value);
}
}
}
return(results);
}
private static void RegisterPacketHandler(int code, IPackageHandler iPackageHandler)
{
PackageHandlers.m_packagesHandlers[code] = iPackageHandler;
}
/// <summary>
/// Initializes a new instance of the <see cref="NugetInstaller"/> class.
/// </summary>
/// <param name="successor">The successor with the same package</param>
public NugetInstaller(IPackageHandler successor)
: base(successor)
{
}
public void Init(IPackageHandler packageHandler)
{
PackageHandler = packageHandler;
}
public RequestHandler(IPackageHandler packageHandler)
{
Logger = AdjustFactory.Logger;
Init(packageHandler);
}
public void Init(IPackageHandler packageHandler)
{
MockLogger.Test("{0} Init", prefix);
}
/// <summary>
/// Initializes a new instance of the <see cref="NuGetUninstaller"/> class.
/// </summary>
/// <param name="successor">The successor with the same package</param>
public NuGetUninstaller(IPackageHandler successor)
: base(successor)
{
}
public static void SetPackageHandler(IPackageHandler packageHandler)
{
IPackageHandler = packageHandler;
}
public RequestHandler(IPackageHandler packageHandler)
{
Logger = AdjustFactory.Logger;
Init(packageHandler);
}
/// <summary>
/// Initializes a new instance of the <see cref="TargetsUninstaller"/> class.
/// </summary>
/// <param name="successor">The successor with the same package</param>
public TargetsUninstaller(IPackageHandler successor)
: base(successor)
{
}
public void Init(IPackageHandler packageHandler)
{
PackageHandler = packageHandler;
}
public static void SetPackageHandler(IPackageHandler packageHandler)
{
IPackageHandler = packageHandler;
}
private static void RegisterPacketHandler(int code, IPackageHandler iPackageHandler)
{
PackageHandlers.m_packagesHandlers[code] = iPackageHandler;
}
/// <summary>
/// Initializes a new instance of the <see cref="UserInstallationHandler"/> class.
/// </summary>
/// <param name="successor">The successor with the same package</param>
public UserInstallationHandler(IPackageHandler successor)
: base(successor)
{
}
public void Initialize(IPackageHandler <TPackageInfo> packageHandler, Func <IAppSession, PackageHandlingException <TPackageInfo>, ValueTask <bool> > errorHandler)
{
PackageHandler = packageHandler;
ErrorHandler = errorHandler;
}
/// <summary>
/// Initializes a new instance of the <see cref="BackgroundInstallationHandler"/> class.
/// </summary>
/// <param name="successor">The successor with the same package</param>
public BackgroundInstallationHandler(IPackageHandler successor)
: base(successor)
{
}
