public async Task PublishArtifacts_ItemNotExists_ThrowsResourceNotFoundException()
{
_versionControlRepository.Setup(
a => a.GetDiscardPublishStates(It.IsAny <int>(), It.IsAny <IEnumerable <int> >(), It.IsAny <IDbTransaction>()))
.ReturnsAsync(new List <SqlDiscardPublishState>
{
new SqlDiscardPublishState
{
NotExist = true
}
});
var versionControlService = new VersionControlService(
_versionControlRepository.Object,
_publishRepository.Object,
_revisionRepository.Object,
_sqlHelper.Object);
var publishParameters = new PublishParameters {
ArtifactIds = new List <int>()
{
1
}
};
await versionControlService.PublishArtifacts(publishParameters);
}
private void ThreadProc()
{
// The event handlers for the data model can't wait on locks and resources outside the data model. There would simply be too many resources that
// could deadlock. This code will pull requests off of a generic queue of actions and parameters and execute them using the authentication created
// above.
while (true)
{
if (this.waitQueue.Count == 0)
{
Thread.Sleep(threadSleepTime);
}
try
{
bool timedOut;
// The thread will wait here until an action has been placed in the queue to be processed in this thread context.
PublishParameters parameters = this.waitQueue.Dequeue(threadWaitTime, out timedOut);
if (parameters == null)
{
continue;
}
this.PublishProc(parameters);
}
catch (ThreadAbortException)
{
return;
}
catch (Exception exception)
{
// This will catch any exceptions thrown during the processing of the generic actions.
FluidTrade.Core.EventLog.Error("{0} {1}: {2}\r\n{3}", Thread.CurrentThread.Name, exception.Message, exception.ToString(), exception.StackTrace);
}
}
}
private void PublishProc(PublishParameters publishParameters)
{
if (publishParameters.ClientProxy.IsUnsubscribed == true)
{
return;
}
try
{
if (((ICommunicationObject)publishParameters.ClientProxy.CallBack).State == CommunicationState.Opened)
{
try
{
int start = Environment.TickCount;
publishParameters.PublishHandler(publishParameters.ClientProxy, publishParameters.PublishEventArg);
publishParameters.ClientProxy.MarkEndSend(Environment.TickCount - start);
}
catch (Exception ex)
{
publishParameters.ClientProxy.AddPendingMessage(publishParameters.PublishEventArg, publishParameters.PublishHandler);
FluidTrade.Core.EventLog.Error(ex);
}
}
else
{
publishParameters.ClientProxy.AddPendingMessage(publishParameters.PublishEventArg, publishParameters.PublishHandler);
}
}
catch (Exception ex)
{
FluidTrade.Core.EventLog.Error(ex);
}
}
private dynamic InvokePublishing(dynamic o)
{
var publishRequest = this.Bind <PublishRequest>();
if (!IsAllowedPublishingMode(publishRequest.Mode))
{
return(new Response
{
StatusCode = HttpStatusCode.BadRequest
});
}
var publishParameters = new PublishParameters
{
Mode = publishRequest.Mode,
Source = publishRequest.Source ?? "master",
Targets = publishRequest.Targets.CsvStringToStringArray(new[] { "web" }),
Languages = publishRequest.Languages.CsvStringToStringArray(new[] { "en" }),
};
var now = DateTime.Now;
var date = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second);
_publishService.Run(publishParameters);
return(Response.AsJson(date, HttpStatusCode.Accepted));
}
public async Task Execute(int revisionId, PublishParameters parameters, PublishEnvironment environment, IDbTransaction transaction = null)
{
var items = await GetDraftAndLatest <SqlDraftAndLatestItem>(parameters.UserId, parameters.AffectedArtifactIds, transaction);
if (items.Count == 0)
{
return;
}
var hierarchyValidator = new ArtifactsHierarchyValidator(this);
var deleteVersionsIds = new HashSet <int>();
var closeVersionIds = new HashSet <int>();
var markAsLatestVersionIds = new HashSet <int>();
foreach (var item in items)
{
if (item.DraftDeleted)
{
deleteVersionsIds.Add(item.DraftVersionId);
if (item.LatestVersionId.HasValue)
{
closeVersionIds.Add(item.LatestVersionId.Value);
RegisterItemModification(environment.SensitivityCollector, item);
}
environment.AddAffectedArtifact(item.ArtifactId);
}
else
{
if (IsChanged(item))
{
markAsLatestVersionIds.Add(item.DraftVersionId);
if (item.LatestVersionId.HasValue)
{
closeVersionIds.Add(item.LatestVersionId.Value);
}
hierarchyValidator.ScheduleReparentAndReorderArtifactsCheck(item, parameters.AffectedArtifactIds);
environment.AddAffectedArtifact(item.ArtifactId);
RegisterItemModification(environment.SensitivityCollector, item);
}
else
{
deleteVersionsIds.Add(item.DraftVersionId);
}
}
}
await hierarchyValidator.CheckAndFix(environment, transaction);
await MarkAsLatest(markAsLatestVersionIds, environment.RevisionId, transaction);
await DeleteVersions(deleteVersionsIds, transaction);
await CloseVersions(closeVersionIds, environment.RevisionId, transaction);
}
public async Task <ArtifactResultSet> PublishArtifacts(PublishParameters parameters, IDbTransaction transaction = null)
{
IList <int> artifactIdsList;
ICollection <SqlDiscardPublishState> discardPublishStates;
if (parameters.All.HasValue && parameters.All.Value)
{
discardPublishStates = await _versionControlRepository.GetAllDiscardPublish(parameters.UserId, transaction);
artifactIdsList = discardPublishStates.Select(dps => dps.ItemId).ToList();
}
else
{
artifactIdsList = (parameters.ArtifactIds ?? Enumerable.Empty <int>()).Distinct().ToList();
if (!artifactIdsList.Any())
{
throw new BadRequestException("The list of artifact Ids is empty.", ErrorCodes.IncorrectInputParameters);
}
discardPublishStates = await _versionControlRepository.GetDiscardPublishStates(parameters.UserId, artifactIdsList, transaction);
}
HandleErrorStates(artifactIdsList, discardPublishStates);
IDictionary <int, string> projectsNames = new Dictionary <int, string>();
// These artifacts can be published alone.
IList <int> independentArtifactsIds = discardPublishStates.Where(dps => !dps.PublishDependent).Select(dps => dps.ItemId).ToList();
// These artifacts must be published together with other artifacts.
IList <int> dependentArtifactsIds = discardPublishStates.Where(dps => dps.PublishDependent).Select(dps => dps.ItemId).ToList();
if (dependentArtifactsIds.Any())
{
await ProcessDependentArtifactsDiscovery(parameters, dependentArtifactsIds, independentArtifactsIds, projectsNames);
}
PublishEnvironment environment;
if (transaction == null)
{
environment = await _sqlHelper.RunInTransactionAsync
(
ServiceConstants.RaptorMain,
GetPublishTransactionAction(parameters, artifactIdsList));
}
else
{
environment = await TransactionalPublishArtifact(parameters, artifactIdsList, transaction);
}
var discardPublishDetailsResult =
await _versionControlRepository.GetDiscardPublishDetails(parameters.UserId, artifactIdsList, true, transaction);
var discardPublishDetails = discardPublishDetailsResult.Details;
projectsNames = discardPublishDetailsResult.ProjectInfos;
var artifactResultSet = ToNovaArtifactResultSet(discardPublishDetails, environment, projectsNames);
artifactResultSet.RevisionId = parameters.RevisionId;
return(artifactResultSet);
}
public async Task Execute(int revisionId, PublishParameters parameters, PublishEnvironment environment, IDbTransaction transaction = null)
{
// await Task.Run(() => { });
var artifactIds = parameters.ArtifactIds.ToHashSet();
var items = await GetDraftAndLatestAttachments(artifactIds, parameters.UserId, transaction);
if (items.Count == 0)
{
return;
}
var deleteVersionsIds = new HashSet <int>();
var closeVersionIds = new HashSet <int>();
var closeButKeepLatestVersionIds = new HashSet <int>();
var markAsLatestVersionIds = new HashSet <int>();
foreach (var item in items)
{
if (item.DraftDeleted)
{
deleteVersionsIds.Add(item.DraftVersionId);
if (item.LatestVersionId.HasValue)
{
closeButKeepLatestVersionIds.Add(item.LatestVersionId.Value);
RegisterAttachmentModification(environment, item);
}
environment.AddAffectedArtifact(item.ArtifactId);
}
else
{
if (IsChanged(item))
{
markAsLatestVersionIds.Add(item.DraftVersionId);
if (item.LatestVersionId.HasValue)
{
closeVersionIds.Add(item.LatestVersionId.Value);
}
environment.AddAffectedArtifact(item.ArtifactId);
RegisterAttachmentModification(environment, item);
}
else
{
deleteVersionsIds.Add(item.DraftVersionId);
}
}
}
await CloseAttachmentVersions(closeButKeepLatestVersionIds, environment.RevisionId, keepLatest : true, transaction : transaction);
await CloseAttachmentVersions(closeVersionIds, environment.RevisionId, keepLatest : false, transaction : transaction);
await MarkAsLatest(markAsLatestVersionIds, environment.RevisionId, transaction);
await DeleteVersions(deleteVersionsIds, transaction);
}
public void Run(PublishParameters publishParameters)
{
var publishingMode = publishParameters.Mode.ToLower();
if (!_publishingActions.ContainsKey(publishingMode))
{
throw new InvalidOperationException(string.Format("Invalid publishing mode ({0})", publishingMode));
}
PublishingTask(_publishingActions[publishingMode], publishParameters);
}
public async Task PublishArtifacts_EmptyListIds_ThrowsBadRequestException()
{
var versionControlService = new VersionControlService(
_versionControlRepository.Object,
_publishRepository.Object,
_revisionRepository.Object,
_sqlHelper.Object);
var publishParameters = new PublishParameters {
ArtifactIds = new List <int>()
};
await versionControlService.PublishArtifacts(publishParameters);
}
public async Task Execute(int revisionId, PublishParameters parameters, PublishEnvironment environment, IDbTransaction transaction = null)
{
await _repositoriesContainer.PublishItemsRepo.Execute(revisionId, parameters, environment, transaction);
await _repositoriesContainer.PublishRelationshipsRepo.Execute(revisionId, parameters, environment, transaction);
await _repositoriesContainer.PublishPropertiesRepo.Execute(revisionId, parameters, environment, transaction);
await _repositoriesContainer.PublishAttachmentsRepo.Execute(revisionId, parameters, environment, transaction);
await _repositoriesContainer.PublishReuseProcessingRepo.Execute(revisionId, parameters, environment, transaction);
// TODO: DISCUSSIONS IS NOT IMPLEMENTED
// TODO: Collection Assignment IS NOT IMPLEMENTED
// await _repositoriesContainer.PublishCollectionAssignmentsRepo.Execute(revisionId, parameters, environment, transaction);
}
public async Task Execute(int revisionId, PublishParameters parameters, PublishEnvironment environment, IDbTransaction transaction = null)
{
var affectedArtifacts = environment.GetAffectedArtifacts().Where(a => {
SqlItemInfo info;
if (environment.ArtifactStates.TryGetValue(a, out info))
{
return(info.PrimitiveItemTypePredefined.IsAvailableForSensitivityCalculations());
}
return(true);
}).ToList();
var affectedStandardArtifacts = await _sensitivityCommonHelper.FilterInsensitiveItems(affectedArtifacts,
environment.SensitivityCollector,
_reuseRepository);
await MarkReuseLinksOutOfSync(affectedStandardArtifacts, environment, transaction);
}
private static PublishParameters GetRequest(HttpRequestBase request)
{
if (request.Url == null)
{
throw new InvalidOperationException("Missing Url");
}
var publishRequest = new PublishParameters
{
Mode = request.Url.PathAndQuery.Split(new[] { '/' }).Last(),
Source = request.Form["source"] ?? "master",
Targets = request.Form["targets"].CsvStringToStringArray(new[] { "web" }),
Languages = request.Form["languages"].CsvStringToStringArray(new[] { "en" })
};
return(publishRequest);
}
public PublishItemParameters(string fileType)
{
switch (fileType)
{
case "serviceDefinition" :
break;
case "shapefile" :
PublishParameters = new PublishParametersShapefile();
break;
case "csv" :
//TODO create CSV publish params
break;
}
FileType = fileType;
}
private async Task ProcessDependentArtifactsDiscovery(PublishParameters parameters, IList <int> dependentArtifactsIds,
IList <int> independentArtifactsIds, IDictionary <int, string> projectsNames)
{
ICollection <int> publishDependentArtifacts = await _versionControlRepository.GetDiscardPublishDependentArtifacts(
parameters.UserId, dependentArtifactsIds, false);
if (publishDependentArtifacts.Any())
{
IEnumerable <int> unitedArtifactsIds =
publishDependentArtifacts.Union(dependentArtifactsIds).Union(independentArtifactsIds);
var discardPublishDetails =
(await _versionControlRepository.GetDiscardPublishDetails(parameters.UserId, unitedArtifactsIds, true))
.Details;
// We are supposed to throw an exception here for providing appropriate information to client
throw new ConflictException("Specified artifacts have dependent artifacts to discard.",
ErrorCodes.CannotDiscardOverDependencies,
ToNovaArtifactResultSet(discardPublishDetails, null, projectsNames));
}
}
public async Task AddArtifactChanges(PublishParameters parameters, PublishEnvironment environment, IDbTransaction transaction = null)
{
var affectedArtifacts = environment.GetAffectedArtifacts();
foreach (var item in environment.ArtifactStates)
{
ActionType action;
if (environment.DeletedArtifactIds.Contains(item.Key))
{
action = ActionType.Removed;
}
else if (affectedArtifacts.Contains(item.Key))
{
action = item.Value.HasNeverBeenPublished ? ActionType.Added : ActionType.Updated;
}
else
{
// Skip not changed artifacts
continue;
}
try
{
await AddEntry(
new SqlJournalEntry
{
RevisionID = environment.RevisionId,
TimeStamp = environment.Timestamp,
UserID = parameters.UserId,
ItemID = item.Value.ItemId,
ElementType = (int)ElementType.Artifact,
ActionType = (int)action
});
}
catch (Exception)
{
// swallow
}
}
}
public PublishModuleBehaviour()
{
_mockPublishService = new Mock <IPublishService>();
_mockAuthoriser = new Mock <IAuthoriser>();
var bootstrapper = new ConfigurableBootstrapper(with =>
{
with.Module <PublishModule>();
with.Dependency(_mockPublishService.Object);
with.Dependency(_mockAuthoriser.Object);
});
_browser = new Browser(bootstrapper);
_mockAuthoriser.Setup(x => x.IsAllowed()).Returns(true);
_publishParameters = null;
_mockPublishService
.Setup(x => x.Run(It.IsAny <PublishParameters>()))
.Callback <PublishParameters>(x => _publishParameters = x);
}
public async Task PublishArtifacts_ItemCountMismatch_ThrowsBadRequestException()
{
_versionControlRepository.Setup(
a => a.GetDiscardPublishStates(It.IsAny <int>(), It.IsAny <IEnumerable <int> >(), It.IsAny <IDbTransaction>()))
.ReturnsAsync(new List <SqlDiscardPublishState>
{
new SqlDiscardPublishState()
});
var versionControlService = new VersionControlService(
_versionControlRepository.Object,
_publishRepository.Object,
_revisionRepository.Object,
_sqlHelper.Object);
var publishParameters = new PublishParameters {
ArtifactIds = new List <int>()
{
1, 2, 3
}
};
await versionControlService.PublishArtifacts(publishParameters);
}
public void Publish(IMessageWrapper messageWrapper)
{
PublishParameters.Add(messageWrapper);
}
public async Task Execute(int revisionId, PublishParameters parameters, PublishEnvironment environment, IDbTransaction transaction = null)
{
await AddArtifactChanges(parameters, environment, transaction);
}
public async Task Execute(int revisionId, PublishParameters parameters, PublishEnvironment environment, IDbTransaction transaction = null)
{
await Task.Run(() => { });
}
public async Task Execute(int revisionId, PublishParameters parameters, PublishEnvironment environment, IDbTransaction transaction = null)
{
// await Task.Run(() =>
// {
var artifactIds = parameters.ArtifactIds.ToHashSet();
var draftAndLatestLinks = await GetDraftAndLatestLinks(artifactIds, parameters.UserId, transaction);
if (!draftAndLatestLinks.Any())
{
return;
}
var deleteLinkVersionsIds = new HashSet <int>();
var closeLinkVersionIds = new HashSet <int>();
var markAsLatestLinkVersionIds = new HashSet <int>();
foreach (var link in await FilterLinksThatCannotBePublished(draftAndLatestLinks, artifactIds))
{
if (link.DraftDeleted)
{
deleteLinkVersionsIds.Add(link.DraftVersionId);
if (link.LatestVersionId.HasValue)
{
closeLinkVersionIds.Add(link.LatestVersionId.Value);
MarkArtifactsAsAffectedIfRequired(link, artifactIds, environment);
if (link.Type == LinkType.Reuse)
{
await DeleteReuseMapping(link.Item1Id, link.Item2Id, environment.RevisionId, transaction);
}
RegisterLinkModification(environment, link);
}
}
else
{
if (IsChanged(link))
{
markAsLatestLinkVersionIds.Add(link.DraftVersionId);
if (link.LatestVersionId.HasValue)
{
closeLinkVersionIds.Add(link.LatestVersionId.Value);
}
MarkArtifactsAsAffectedIfRequired(link, artifactIds, environment);
RegisterLinkModification(environment, link);
}
else
{
// For unchanged link - delete the draft
deleteLinkVersionsIds.Add(link.DraftVersionId);
}
}
}
await DeleteLinkVersions(deleteLinkVersionsIds, transaction);
await CloseVersions(closeLinkVersionIds, environment.RevisionId, transaction);
await MarkAsLatest(markAsLatestLinkVersionIds, environment.RevisionId, transaction);
// });
}
private async Task <PublishEnvironment> TransactionalPublishArtifact(PublishParameters parameters,
IList <int> artifactIdsList,
IDbTransaction transaction)
{
int publishRevision = parameters.RevisionId ?? await
_sqlHelper.CreateRevisionInTransactionAsync(transaction, parameters.UserId,
"New Publish: publishing artifacts.");
parameters.RevisionId = publishRevision;
parameters.AffectedArtifactIds.Clear();
parameters.AffectedArtifactIds.AddRange(artifactIdsList);
var publishResults = new List <SqlPublishResult>(parameters.AffectedArtifactIds.Count);
var artifactStates =
await _versionControlRepository.GetPublishStates(parameters.UserId, parameters.AffectedArtifactIds, transaction : transaction);
var artifactsCannotBePublished = _versionControlRepository.CanPublish(artifactStates);
parameters.AffectedArtifactIds.ExceptWith(artifactsCannotBePublished.Keys);
// Notify about artifactsCannotBePublished - callback
// if (onError != null && onError(new ReadOnlyDictionary<int, PublishErrors>(artifactsCannotBePublished)))
// {
// throw new DataAccessException("Publish interrupted", BusinessLayerErrorCodes.RequiredArtifactHasNotBeenPublished);
// }
if (parameters.AffectedArtifactIds.Count == 0)
{
return(null);
}
var env = new PublishEnvironment
{
RevisionId = publishRevision,
Timestamp = DateTime.UtcNow, // Need to get if from created revision - DB timestamp
KeepLock = false,
ArtifactStates = artifactStates.ToDictionary(s => s.ItemId),
Repositories = null,
SensitivityCollector = new ReuseSensitivityCollector()
};
if (parameters.AffectedArtifactIds.Count <= 0)
{
return(env);
}
env.DeletedArtifactIds.Clear();
env.DeletedArtifactIds.AddRange(
await _versionControlRepository.DetectAndPublishDeletedArtifacts(parameters.UserId,
parameters.AffectedArtifactIds,
env, transaction));
parameters.AffectedArtifactIds.ExceptWith(env.DeletedArtifactIds);
// Release lock
if (!env.KeepLock)
{
await _versionControlRepository.ReleaseLock(parameters.UserId, parameters.AffectedArtifactIds, transaction);
}
await _publishRepositoryComposer.Execute(publishRevision, parameters, env, transaction);
// Add history
await _revisionRepository.AddHistory(publishRevision, parameters.AffectedArtifactIds, transaction);
// });
publishResults.AddRange(env.GetChangeSqlPublishResults());
return(env);
}
private Func <IDbTransaction, long, Task <PublishEnvironment> > GetPublishTransactionAction(PublishParameters parameters, IList <int> artifactIdsList)
{
Func <IDbTransaction, long, Task <PublishEnvironment> > action = async(transaction, transactionId) =>
await TransactionalPublishArtifact(parameters, artifactIdsList, transaction);
return(action);
}
public async Task Execute(int revisionId, PublishParameters parameters, PublishEnvironment environment, IDbTransaction transaction = null)
{
var properties = await GetDraftAndLatest <SqlDraftAndLatestProperty>(parameters.UserId, parameters.AffectedArtifactIds, transaction);
if (properties.Count == 0)
{
return;
}
var deleteVersionsIds = new HashSet <int>();
var closeVersionIds = new HashSet <int>();
var markAsLatestVersionIds = new HashSet <int>();
foreach (var property in properties)
{
if (property.DraftDeleted)
{
deleteVersionsIds.Add(property.DraftVersionId);
if (property.LatestVersionId.HasValue)
{
closeVersionIds.Add(property.LatestVersionId.Value);
// TODO: reviews are not handled currently
// _reviewProcessor.ProcessArtifactReviewPackageChanges(property, environment);
RegisterPropertyModification(environment.SensitivityCollector, property);
}
environment.AddAffectedArtifact(property.ArtifactId);
}
else
{
if (IsChanged(property))
{
markAsLatestVersionIds.Add(property.DraftVersionId);
if (property.LatestVersionId.HasValue)
{
closeVersionIds.Add(property.LatestVersionId.Value);
}
// TODO: reviews are not handled currently
// _reviewProcessor.ProcessArtifactReviewPackageChanges(property, environment);
environment.AddAffectedArtifact(property.ArtifactId);
RegisterPropertyModification(environment.SensitivityCollector, property);
}
else
{
deleteVersionsIds.Add(property.DraftVersionId);
}
}
}
await ClosePropertyVersions(closeVersionIds, environment.RevisionId, transaction);
await CloseVersionsForCrossProjectMovedArtifacts(environment.GetArtifactsMovedAcrossProjects(parameters.AffectedArtifactIds),
environment.RevisionId,
transaction);
await DeleteVersions(deleteVersionsIds, transaction);
await MarkAsLatest(markAsLatestVersionIds, environment.RevisionId, transaction);
}
private static void PublishingTask(Func <Database, Database[], Language[], Handle> publishType, PublishParameters publishParameters)
{
using (new SecurityModel.SecurityDisabler())
{
var master = Sitecore.Configuration.Factory.GetDatabase(publishParameters.Source);
var targetDBs = publishParameters.Targets.Select(Sitecore.Configuration.Factory.GetDatabase).ToArray();
var languages = publishParameters.Languages.Select(LanguageManager.GetLanguage).ToArray();
publishType(master, targetDBs, languages);
}
}
