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); }
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); }
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 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); }