public SynchronizedLinks(ISynchronization synchronization, ILinks <TLinkAddress> links)
{
SyncRoot = synchronization;
Sync = this;
Unsync = links;
Constants = links.Constants;
}
public DiffProcessor(IWorkerConfiguration workerConfig, ISynchronization sync, ISvc source, ISvc target, IBlackMirrorHttpClient httpClient, ISyncLogger syncLogger, IUser defaultPushUser)
{
//this.mirror = mirror;
this.sync = sync;
this.source = source;
this.target = target;
this.httpClient = httpClient;
this.syncLogger = syncLogger;
this.defaultPushUser = defaultPushUser;
this.ignoredFiles = sync.Mirror.IgnoredFiles?.ToList() ?? new List <string>();
this.ignoredFiles.AddRange(new[]
{
@"^\.svn\\?.*$",
@"(^\.git\\.*$)|(^\.git$)",
@"^.*\\node_modules\\.*$",
@"^.*\\bower_components\\.*$",
@"^packages\\?.*$",
@"^.*\.dll$",
@"^.*\.pdb",
@"^.*\.nupkg",
@"^.*\.tar",
@"^.*\.tgz",
@"^.*\.jar",
@"^.*\.exe",
});
this.retriever = new UserRetriever(workerConfig);
this.timeoutMaxRetryCount = workerConfig.TimeoutMaxRetryCount;
}
public static string GitRepositoryPath(ISynchronization sync)
{
var runPath = AppDomain.CurrentDomain.BaseDirectory;
string path = Path.Combine(runPath, "workspace", sync.Id, "git");
return(path);
}
/// <summary>
/// Saves the synchronization interval to the configuration file.
/// </summary>
/// <param name="form">The Synchronization form.</param>
/// <param name="args">The <see cref="System.EventArgs"/> instance containing the event data.</param>
public static void btnSave_OnClickStep(ISynchronization form, EventArgs args)
{
IAppIdMapping appIdMapping = form.CurrentEntity as IAppIdMapping;
int syncInterval = Convert.ToInt32(form.txtInterval.Text);
appIdMapping.SaveSyncConfiguration(syncInterval);
appIdMapping.Save();
}
public IEnumerable <Reflection> GetBySync(ISynchronization sync, int?take)
{
var syncId = new ObjectId(sync.Id);
var filter = Builders <BsonDocument> .Filter.Eq("SynchronizationId", syncId);
var sort = Builders <BsonDocument> .Sort.Descending("_id");
var document = base.collection.Find(filter).Sort(sort).Limit(take);
var result = new List <Reflection>();
if (document != null && document.Count() > 0)
{
using (var cursor = document.ToCursor())
{
while (cursor.MoveNext())
{
using (var enumerator = cursor.Current.GetEnumerator())
{
while (enumerator.MoveNext())
{
var doc = enumerator.Current;
var dto = BsonSerializer.Deserialize <ReflectionDto>(doc);
var model = this.ConvertToModel(dto);
result.Add(model);
}
}
}
}
}
return(result);
}
/// <summary>
/// Saves the synchronization interval to the configuration file.
/// </summary>
/// <param name="form">The Synchronization form.</param>
/// <param name="args">The <see cref="System.EventArgs"/> instance containing the event data.</param>
public static void btnSave_OnClickStep(ISynchronization form, EventArgs args)
{
IAppIdMapping appIdMapping = form.CurrentEntity as IAppIdMapping;
int syncInterval = Convert.ToInt32(form.txtInterval.Text);
appIdMapping.SaveSyncConfiguration(syncInterval);
appIdMapping.Save();
}
public void Handle(ISynchronization sync)
{
try
{
var passwordRetriever = new UserRetriever(this.workerConfig);
var message = $"Starting synchronization {sync.Id}";
Logging.Log().Warning(message);
this.syncLogger.Log(sync, message);
SvcFactory factory = new SvcFactory(sync, passwordRetriever, syncLogger);
ISvc source = factory.Create(sync.Mirror.SourceRepository);
ISvc target = factory.Create(sync.Mirror.TargetRepository);
var diffProcessor = new DiffProcessor(
this.workerConfig,
sync,
source,
target,
this.httpClient,
this.syncLogger,
sync.Mirror.TargetRepository.PushUser);
source.CloneOrUpdate();
target.CloneOrUpdate();
var sourceLog = source.GetLog();
var targetLog = target.GetLog();
var comparer = new RepositoryComparer(this.httpClient, sync.Mirror, sourceLog, targetLog);
var revisions = comparer.GetRevisionsAwaitingForSync();
for (int i = revisions.Count - 1; i >= 0; i--)
{
var revision = revisions[i];
var m = $"Applying revision {revision.Id} {revision.Author} {revision.Message}";
Logging.Log().Warning(m);
this.syncLogger.Log(sync, m);
diffProcessor.ApplyRevision(revision);
}
var o = $"Synchronization {sync.Id} OK";
Logging.Log().Information(o);
this.syncLogger.Log(sync, o);
var cl = $"Cleaning up...";
Logging.Log().Information(cl);
this.syncLogger.Log(sync, cl);
source.CleanUp();
target.CleanUp();
}
catch (Exception ex)
{
this.syncLogger.Log(sync, $"Error: {ex}");
throw;
}
}
public virtual void RegisterSynchronization(ISynchronization synchronization)
{
if (synchronization == null)
{
throw new ArgumentNullException("synchronization");
}
_synchronizations.Add(synchronization);
}
public void RegisterSynchronization(ISynchronization sync)
{
if (sync == null) throw new ArgumentNullException("sync");
if (synchronizations == null)
{
synchronizations = new List<ISynchronization>();
}
synchronizations.Add(sync);
}
public Svn(ISynchronization sync, ISvcRepository repository, string repoPath, string ownerName, string ownerPassword, ISyncLogger syncLogger)
{
this.sync = sync;
this.repository = repository;
this.repoPath = repoPath;
this.username = ownerName;
this.ownerPassword = ownerPassword;
this.syncLogger = syncLogger;
}
public Sequences(SynchronizedLinks <LinkIndex> links, SequencesOptions <LinkIndex> options)
{
Links = links;
_sync = links.SyncRoot;
Options = options;
Options.ValidateOptions();
Options.InitOptions(Links);
Constants = links.Constants;
}
public void RegisterSynchronization(ISynchronization sync)
{
if (sync == null)
{
throw new ArgumentNullException("sync");
}
if (synchronizations == null)
{
synchronizations = new List <ISynchronization>();
}
synchronizations.Add(sync);
}
public static SynchronizationDto ToDto(this ISynchronization sync)
{
var s = new SynchronizationDto
{
CreationTime = sync.CreationTime,
Id = sync.Id,
Mirror = sync.Mirror.ToDto(),
Status = sync.Status
};
return(s);
}
public async Task <SyncLogDto> GetSyncLogAsync(ISynchronization sync)
{
var uri = new Uri(this.syncUri, sync.Id + "/logs");
Logging.Log().Debug($"Sending HTTP GET request to {uri}");
string response = await this.httpClient.GetStringAsync(uri);
var dto = JsonConvert.DeserializeObject <SyncLogDto>(response);
return(dto);
}
/// <summary>
/// Loads the synchronization sync interval from the configuration file.
/// </summary>
/// <param name="form">The Synchronization form.</param>
/// <param name="args">The <see cref="System.EventArgs"/> instance containing the event data.</param>
public static void OnLoadSynchronization(ISynchronization form, EventArgs args)
{
IAppIdMapping appIdMapping = form.CurrentEntity as IAppIdMapping;
try
{
form.txtInterval.Text = appIdMapping.GetSyncCycleInterval().ToString();
}
catch (FormatException)
{
form.txtInterval.Text = "60";
//throw new ValidationException(form.GetResource("Error_Invalid_Number").ToString());
}
}
/// <summary>
/// Saves the synchronization interval to the configuration file.
/// </summary>
/// <param name="form">The Synchronization form.</param>
/// <param name="args">The <see cref="System.EventArgs"/> instance containing the event data.</param>
public static void btnSave_OnClickStep(ISynchronization form, EventArgs args)
{
IAppIdMapping appIdMapping = form.CurrentEntity as IAppIdMapping;
try
{
int syncInterval = Convert.ToInt32(form.txtInterval.Text);
appIdMapping.SaveSyncConfiguration(syncInterval);
}
catch (FormatException)
{
throw new ValidationException(form.GetResource("Error_Invalid_Number").ToString());
}
}
/// <summary>
/// Registers a synchronization object that will be
/// invoked prior and after the transaction completion
/// (commit or rollback)
/// </summary>
/// <param name="s"/>
public virtual void RegisterSynchronization(ISynchronization s)
{
if (s == null)
{
throw new ArgumentNullException("s");
}
if (_SyncInfo.Contains(s))
{
return;
}
_SyncInfo.Add(s);
}
/// <summary>
/// Loads the synchronization sync interval from the configuration file.
/// </summary>
/// <param name="form">The Synchronization form.</param>
/// <param name="args">The <see cref="System.EventArgs"/> instance containing the event data.</param>
public static void OnLoadSynchronization(ISynchronization form, EventArgs args)
{
IAppIdMapping appIdMapping = form.CurrentEntity as IAppIdMapping;
try
{
form.txtInterval.Text = appIdMapping.GetSyncCycleInterval().ToString();
}
catch (FormatException)
{
form.txtInterval.Text = "60";
//throw new ValidationException(form.GetResource("Error_Invalid_Number").ToString());
}
}
/// <summary>
/// Saves the synchronization interval to the configuration file.
/// </summary>
/// <param name="form">The Synchronization form.</param>
/// <param name="args">The <see cref="System.EventArgs"/> instance containing the event data.</param>
public static void btnSave_OnClickStep(ISynchronization form, EventArgs args)
{
IAppIdMapping appIdMapping = form.CurrentEntity as IAppIdMapping;
try
{
int syncInterval = Convert.ToInt32(form.txtInterval.Text);
appIdMapping.SaveSyncConfiguration(syncInterval);
}
catch (FormatException)
{
throw new ValidationException(form.GetResource("Error_Invalid_Number").ToString());
}
}
public Git(ISynchronization sync, ISvcRepository repository, string repoPath, string userName, string password, string refspec, ISyncLogger syncLogger)
{
this.credentials = new UsernamePasswordCredentials {
Username = userName, Password = password
};
this.sync = sync;
this.repository = repository;
this.repoPath = repoPath;
this.userName = userName;
this.refspec = refspec;
this.syncLogger = syncLogger;
if (Repository.IsValid(repoPath))
{
this.repo = new Repository(repoPath);
}
}
/// <summary>
/// Registers a synchronization object that will be
/// invoked prior and after the transaction completion
/// (commit or rollback)
/// </summary>
/// <param name="s"/>
public void RegisterSynchronization(ISynchronization s)
{
if (s == null)
{
throw new ArgumentNullException("s");
}
_Sem.AtomWrite(() =>
{
if (_SyncInfo.Contains(s))
{
return;
}
_SyncInfo.Add(s);
});
}
public async void SetSynchronizationStatus(ISynchronization sync, SynchronizationStatus status, string additionalInfo = null)
{
var uri = new Uri(this.syncUri, sync.Id + "/status");
string body = $@"{{""Status"":""{status}""}}";
Logging.Log().Debug($"Sending HTTP PUT request to {uri} with body {body}");
var content = new StringContent(body, Encoding.UTF8, "application/json");
var response = await this.httpClient.PutAsync(uri, content);
if (response.StatusCode != HttpStatusCode.OK)
{
throw new StatusNotChangedException(response.ReasonPhrase);
}
}
public SyncLogDto Get(ISynchronization sync)
{
var objectId = new BsonObjectId(new ObjectId(sync.Id));
var filter = Builders <BsonDocument> .Filter.Eq("SyncId", objectId);
var document = this.collection.Find(filter).FirstOrDefault();;
if (document == null)
{
return(null);
}
var dto = BsonSerializer.Deserialize <SyncLogDto>(document);
return(dto);
}
private void NotifyLocalSynchsBeforeTransactionCompletion()
{
if (synchronizations != null)
{
for (int i = 0; i < synchronizations.Count; i++)
{
ISynchronization sync = synchronizations[i];
try
{
sync.BeforeCompletion();
}
catch (Exception e)
{
Log.Error("exception calling user Synchronization", e);
}
}
}
}
private void NotifyLocalSynchsAfterTransactionCompletion(bool?success)
{
if (synchronizations != null)
{
for (int i = 0; i < synchronizations.Count; i++)
{
ISynchronization sync = synchronizations[i];
try
{
sync.AfterCompletion(success ?? false);
}
catch (Exception e)
{
Log.Error("exception calling user Synchronization", e);
}
}
}
}
public async Task AddSyncLogAsync(ISynchronization sync, string text)
{
var uri = new Uri(this.syncUri, sync.Id + "/logs");
Logging.Log().Debug($"Sending HTTP PUT request to {uri}");
var dto = new SyncLogDto {
Text = text, SyncId = sync.Id
};
var json = JsonConvert.SerializeObject(dto);
HttpContent content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await this.httpClient.PutAsync(uri, content);
if (!response.IsSuccessStatusCode)
{
Logging.Log().Error($"HTTP PUT request to {uri} failed {response.StatusCode}");
}
}
public void LogSync(ISynchronization sync, string text)
{
var objectId = new BsonObjectId(new ObjectId(sync.Id));
var updateObject = new
{
Timestamp = DateTime.Now,
Text = text
};
var filter = Builders <BsonDocument> .Filter.Eq("SyncId", objectId);
var update = Builders <BsonDocument> .Update.Push("Logs", updateObject);
this.collection.FindOneAndUpdate(
filter,
update,
new FindOneAndUpdateOptions <BsonDocument> {
IsUpsert = true
});
}
private void NotifyLocalSynchsBeforeTransactionCompletion()
{
if (synchronizations != null)
{
for (int i = 0; i < synchronizations.Count; i++)
{
ISynchronization sync = synchronizations[i];
try
{
sync.BeforeCompletion();
}
catch (Exception e)
{
log.Error("exception calling user Synchronization", e);
#pragma warning disable 618
if (!session.Factory.Settings.IsInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled)
{
throw;
}
#pragma warning restore 618
}
}
}
}
private static void InitializeWin32()
{
Environment = new Win32Environment();
Synchronization = new Win32Synchronization();
}
public override void RegisterSynchronization(ISynchronization synchronization)
{
_parent.RegisterSynchronization(synchronization);
}
/// <summary>
/// Registers a synchronization object that will be
/// invoked prior and after the transaction completion
/// (commit or rollback)
/// </summary>
/// <param name="s"/>
public void RegisterSynchronization(ISynchronization s)
{
if (s == null) throw new ArgumentNullException("s");
_Sem.AtomWrite(() =>
{
if (_SyncInfo.Contains(s)) return;
_SyncInfo.Add(s);
});
}
public void RemoveSynchronization(ISynchronization synchronization)
{
synchronizations.Remove(synchronization);
}
/// <summary>
/// Method AddSynchronization
/// </summary>
public void AddSynchronization(ISynchronization synchronization)
{
synchronizations.Add(synchronization);
}
public override void RegisterSynchronization(ISynchronization synchronization)
{
}
/// <summary>
/// Registers a synchronization object that will be
/// invoked prior and after the transaction completion
/// (commit or rollback)
/// </summary>
/// <param name="s"/>
public virtual void RegisterSynchronization(ISynchronization s)
{
if (s == null) throw new ArgumentNullException("s");
if (_SyncInfo.Contains(s)) return;
_SyncInfo.Add(s);
}
public void RegisterSynchronization(ISynchronization synchronization)
{
throw new NotImplementedException();
}
public void RegisterSynchronization(ISynchronization synchronization)
{
throw new System.NotImplementedException();
}
public virtual void RegisterSynchronization(ISynchronization synchronization)
{
throw new NotSupportedException();
}
/// <summary> /// Method AddSynchronization /// </summary> public void AddSynchronization(ISynchronization synchronization) => _synchronizations.Add(synchronization);
public void RegisterSynchronization(ISynchronization synchronization)
{
_transaction.RegisterSynchronization(synchronization);
}
public void RemoveSynchronization(ISynchronization synchronization)
{
synchronizations.Remove(synchronization);
}
public virtual void RegisterSynchronization(ISynchronization synchronization)
{
logger.DebugFormat("Registering Synchronization {0}", synchronization);
if (synchronization == null) throw new ArgumentNullException("synchronization");
synchronizations.Add(synchronization);
logger.DebugFormat("Synchronization registered successfully {0}", synchronization);
}
public override void RegisterSynchronization(ISynchronization s)
{
_Parent.RegisterSynchronization(s);
}
public ISynchronization Pull()
{
ISynchronization result = this.PullAsync().Result;
return(result);
}
public override void RegisterSynchronization(ISynchronization synchronization)
{
}
public void RegisterSynchronization(ISynchronization synchronization)
{
_transaction.RegisterSynchronization(synchronization);
}
