public CuratorFrameworkImpl(CuratorFrameworkFactory.Builder builder)
{
IZookeeperFactory localZookeeperFactory = makeZookeeperFactory(builder.GetZookeeperFactory());
this.client = new CuratorZookeeperClient(localZookeeperFactory,
builder.GetEnsembleProvider(),
builder.GetSessionTimeoutMs(),
builder.GetConnectionTimeoutMs(),
new WatchedWatcher(this),
builder.GetRetryPolicy(),
builder.CanBeReadOnly());
listeners = new ListenerContainer <ICuratorListener>();
unhandledErrorListeners = new ListenerContainer <IUnhandledErrorListener>();
backgroundOperations = new DelayQueue <OperationAndData <object> >();
@namespace = new NamespaceImpl(this, builder.GetNamespace());
maxCloseWaitMs = builder.GetMaxCloseWaitMs();
connectionStateManager = new ConnectionStateManager(this, builder.GetEventQueueSize());
compressionProvider = builder.GetCompressionProvider();
aclProvider = builder.GetAclProvider();
state = new AtomicReference <CuratorFrameworkState>(CuratorFrameworkState.LATENT);
useContainerParentsIfAvailable = builder.UseContainerParentsIfAvailable();
byte[] builderDefaultData = builder.GetDefaultData();
byte[] destDefaults = new byte[builderDefaultData.Length];
Array.Copy(builderDefaultData, destDefaults, builderDefaultData.Length);
defaultData = (builderDefaultData != null)
? destDefaults
: new byte[0];
authInfos = buildAuths(builder);
failedDeleteManager = new FailedDeleteManager(this);
namespaceWatcherMap = new NamespaceWatcherMap(this);
namespaceFacadeCache = new NamespaceFacadeCache(this);
}
/// <summary>
///
/// </summary>
/// <param name="command"></param>
/// <param name="dataTable"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public static int Fill(this IDbCommand command, DataTable dataTable, CancellationToken cancellationToken)
{
Assert.IsNotNull(command);
var rowCount = 0;
if (!cancellationToken.IsCancellationRequested)
{
var connection = command.Connection;
using (var connectionStateManager = new ConnectionStateManager(connection))
{
connectionStateManager.Open();
try
{
using (var dataReader = command.ExecuteReader())
rowCount = dataReader.Fill(dataTable, cancellationToken);
}
catch (Exception exception)
{
throw new DbCommandExecutionException("IDbCommandExtensions.Fill failed.", exception, command);
}
}
}
return(rowCount);
}
public DbDataReader ExecuteReader(string sql)
{
// Data readers require the connection to remain open during the lifetime of the reader,
// so we cannot manage the connection state other than ensuring it is open for the caller.
this.ConfigureCommand(sql);
ConnectionStateManager.OpenConnection(this.Command.Connection);
return(this.Command.ExecuteReader());
}
public bool ExecuteCommand(string sql)
{
this.ConfigureCommand(sql);
using (var csm = new ConnectionStateManager(this.Command.Connection))
{
this.Command.ExecuteNonQuery();
this.UpdateOutParameters();
}
return(true);
}
public bool FillDataTable(string sql, ref DataTable dt)
{
this.ConfigureCommand(sql);
using (var csm = new ConnectionStateManager(this.Command.Connection))
{
dt.BeginLoadData();
dt.Load(this.Command.ExecuteReader());
dt.EndLoadData();
}
this.UpdateOutParameters();
return(true);
}
public object ExecuteScaler(string sql)
{
object result = null;
this.ConfigureCommand(sql);
using (var csm = new ConnectionStateManager(this.Command.Connection))
{
result = this.Command.ExecuteScalar();
this.UpdateOutParameters();
}
return(result);
}
/// <summary>
/// TODO: Добавить DI.
/// </summary>
static void Main(string[] args)
{
IConnectionStateManager connectionStateManager = new ConnectionStateManager();
IFileManager fileManager = new FileManager(new FileSystemService());
var apiController = new ApiController();
var settingsManager = new SettingsManager();
ISyncTableDataBase syncDb = new SyncTableDataBase();
IUserTableDataBase userDb = new UserTableDataBase();
var telegramService = new TelegramService(settingsManager.Settings.Token, settingsManager.Settings.Telegram_id);
telegramService.Configure("/clean_folders", "clean empty folders", () =>
{
var ls = userDb.GetAvailableFolders();
var removedList = fileManager.RemoveEmptyDirectories(ls);
var sb = new StringBuilder();
sb.AppendLine("Removed dictionaries:");
sb.AppendJoin(Environment.NewLine, removedList);
SendToTelegram(sb.ToString());
});
var syncModule = new CoreModule(fileManager, syncDb, connectionStateManager, userDb);
syncModule.Initialize(apiController);
syncModule.SendMessage += (o, s) => SendToTelegram(s);
var attachModule = new FilesApi(new FilesService(connectionStateManager, syncDb), connectionStateManager);
attachModule.Initialize(apiController);
attachModule.SendMessage += (o, s) => SendToTelegram(s);
var configModule = new ConfigurationModule(userDb, syncDb);
configModule.Initialize(apiController);
configModule.SendMessage += (o, s) => SendToTelegram(s);
var ws = new WsService(connectionStateManager, apiController, IPAddress.Parse(settingsManager.Settings.IpAddress), settingsManager.Settings.HttpPort, settingsManager.Settings.HttpsPort);
ws.Start();
void SendToTelegram(string message)
{
telegramService.SendTextMessageAsync(message);
}
// TODO: Добавить CancellationToken
Console.ReadKey(true);
ws.Stop();
}
protected CuratorFrameworkImpl(CuratorFrameworkImpl parent)
{
client = parent.client;
listeners = parent.listeners;
unhandledErrorListeners = parent.unhandledErrorListeners;
maxCloseWaitMs = parent.maxCloseWaitMs;
backgroundOperations = parent.backgroundOperations;
connectionStateManager = parent.connectionStateManager;
defaultData = parent.defaultData;
failedDeleteManager = parent.failedDeleteManager;
compressionProvider = parent.compressionProvider;
aclProvider = parent.aclProvider;
namespaceFacadeCache = parent.namespaceFacadeCache;
@namespace = new NamespaceImpl(this, null);
state = parent.state;
authInfos = parent.authInfos;
_useContainerParentsIfAvailable = parent._useContainerParentsIfAvailable;
}
public static int Fill(this IDbCommand command, DataSet dataSet, CancellationToken cancellationToken)
{
Assert.IsNotNull(command);
Assert.IsNotNull(dataSet);
var rowCount = 0;
var resultIndex = 0;
var dataTables = dataSet.Tables;
if (!cancellationToken.IsCancellationRequested)
{
var connection = command.Connection;
using (var connectionStateManager = new ConnectionStateManager(connection))
{
connectionStateManager.Open();
using (var reader = command.ExecuteReader())
{
while (true)
{
var fieldCount = reader.FieldCount;
if (fieldCount > 0)
{
DataTable table;
if (resultIndex < dataTables.Count)
{
table = dataTables[resultIndex];
}
else
{
table = new DataTable
{
Locale = CultureInfo.InvariantCulture
};
dataSet.Tables.Add(table);
}
var count = reader.Fill(table, cancellationToken);
rowCount += count;
}
if (!cancellationToken.IsCancellationRequested)
{
var nextResult = reader.NextResult();
if (!nextResult)
{
break;
}
}
else
{
break;
}
resultIndex++;
}
}
}
}
return(rowCount);
}
private void Awake()
{
singleton = this;
}
