private void AddRepo(RepositorySettings repo, TabPage page)
{
RepositoryEntry ar1 = new RepositoryEntry(repo);
repos.Add(ar1);
page.Controls.Add(ar1);
ar1.Dock = DockStyle.Top;
}
/// <summary>
/// Gets the disposition of the verb that generated a build object.
/// </summary>
/// <param name="obj">The object in question.</param>
/// <returns>Disposition of the object.</returns>
public Disposition GetDisposition(BuildObject obj)
{
RepositoryEntry value = this.GetValue(obj);
if (value != null)
{
return(value.Disposition);
}
return(new Stale());
}
public void GetById()
{
// Arrange
BookmarksController controller = new BookmarksController(this.BookmarksRepository);
// Act
RepositoryEntry result = controller.Get(5);
// Assert
Assert.AreEqual("value", result);
}
public void Put()
{
// Arrange
BookmarksController controller = new BookmarksController(this.BookmarksRepository);
RepositoryEntry item = new RepositoryEntry();
// Act
controller.Put(5, item);
// Assert
}
private bool IsLastSelected([CanBeNull] RepositoryEntry repositoryEntry)
{
if (repositoryEntry == null)
{
return(false);
}
if (LastSelection == null)
{
return(false);
}
return(repositoryEntry.Name == LastSelection.Name && repositoryEntry.Location == LastSelection.Location);
}
private void AddLocation()
{
var name = NameTextBox.Text ?? string.Empty;
var location = LocationTextBox.Text ?? string.Empty;
var repository = new RepositoryEntry(name, location);
var listBoxItem = GetListBoxItem(repository);
List.SelectedIndex = List.Items.Add(listBoxItem);
NameTextBox.Text = string.Empty;
LocationTextBox.Text = string.Empty;
EnableButtons();
}
/// <summary>
/// Fetches information about the given object in this repository.
/// </summary>
/// <param name="obj">The object to fetch.</param>
/// <returns>Information about the object.</returns>
private RepositoryEntry FetchFresh(BuildObject obj)
{
RepositoryEntry value = this.GetValue(obj);
if (value == null)
{
throw new ObjectNotReadyException(obj);
}
if (value.Disposition is Failed)
{
throw new ObjectFailedException(obj, (Failed)value.Disposition);
}
Util.Assert(value.Disposition is Fresh); // This isn't really a 'not ready' condition; we shouldn't be here. REVIEW: What is meant by this comment?
return(value);
}
/// <summary>
/// Fetches a build object and stores it in the local filesystem.
/// </summary>
/// <param name="workingDirectory">
/// Directory under which to store the fetched object.
/// </param>
/// <param name="obj">The object to fetch.</param>
public void Fetch(WorkingDirectory workingDirectory, BuildObject obj)
{
RepositoryEntry entry = this.FetchFresh(obj);
// REVIEW: best way to determine this is a source file?
ItemCacheContainer container;
if (obj is SourcePath)
{
container = ItemCacheContainer.Sources;
}
else
{
container = ItemCacheContainer.Objects;
}
this.itemCache.FetchItemToFile(container, entry.Hash, workingDirectory.PathTo(obj));
}
public static RestartReason CheckForUpdates(string identifier, string updateUrl)
{
// Don't check for updates on non-DEPLOY builds; the URLs don't work and it seems
// undesirable anyway.
#if DEPLOY
IVsExtensionManager extensionManager = Package.GetGlobalService(typeof(SVsExtensionManager)) as IVsExtensionManager;
IInstalledExtension installedExtension = extensionManager.GetInstalledExtension(identifier);
if (installedExtension == null)
{
throw new Exception(String.Format("Unable to find extension: {0}", identifier));
}
RepositoryEntry entry = new RepositoryEntry();
entry.DownloadUrl = updateUrl;
IVsExtensionRepository repository = Package.GetGlobalService(typeof(SVsExtensionRepository)) as IVsExtensionRepository;
IInstallableExtension latestExtension = repository.Download(entry);
if (latestExtension.Header.Version > installedExtension.Header.Version)
{
RestartReason reason = RestartReason.None;
reason |= extensionManager.Disable(installedExtension);
extensionManager.Uninstall(installedExtension);
try {
reason |= extensionManager.Install(latestExtension, /*perMachine*/ false);
// Enable the new one.
IInstalledExtension latestInstalledExtension = extensionManager.GetInstalledExtension(latestExtension.Header.Identifier);
reason |= extensionManager.Enable(latestInstalledExtension);
return(reason);
} catch {
// Revert the uninstallation.
extensionManager.RevertUninstall(installedExtension);
extensionManager.Enable(installedExtension);
throw;
}
}
#endif
return(RestartReason.None);
}
/// <summary>
/// Gets a readable stream for the given build object contents.
/// </summary>
/// <param name="obj">The object in question.</param>
/// <returns>An open, readable stream to the contents.</returns>
public TextReader OpenRead(BuildObject obj)
{
RepositoryEntry entry = this.FetchFresh(obj);
// REVIEW: best way to determine this is a source file?
ItemCacheContainer container;
if (obj is SourcePath)
{
container = ItemCacheContainer.Sources;
}
else
{
container = ItemCacheContainer.Objects;
}
byte[] contents = this.itemCache.FetchItem(container, entry.Hash);
MemoryStream stream = new MemoryStream(contents, false);
return(new StreamReader(stream));
}
protected override void OnSelectionChanged(SelectionChangedEventArgs e)
{
Debug.ArgumentNotNull(e, nameof(e));
var comboxBoxItem = SelectedItem as ComboBoxItem;
if (comboxBoxItem != null)
{
if (comboxBoxItem.Content as string == "<Repositories>")
{
var repositoryList = RepositoryManager.GetRepository(RepositoryName);
if (repositoryList.Edit("Repositories"))
{
RenderItems();
}
if (LastSelection == null)
{
SelectedItem = null;
}
else
{
SelectedItem = Items.OfType <ComboBoxItem>().FirstOrDefault(i => IsLastSelected(i.Tag as RepositoryEntry));
}
e.Handled = true;
return;
}
}
if (!IsLoading)
{
LastSelection = SelectedRepositoryEntry;
}
base.OnSelectionChanged(e);
}
/// <summary>
/// Add information about an object to the Repository.
/// </summary>
/// <param name="obj">The object to add.</param>
/// <param name="disposition">
/// Disposition of the verb which created this object.
/// </param>
/// <param name="hash">Hash of the object's contents.</param>
/// <param name="contents">Contents of the object (if virtual).</param>
private void Add(BuildObject obj, Disposition disposition, string hash, VirtualContents contents)
{
// Every object in the repository should either have a hash value
// or virtual contents, but not both.
Util.Assert((string.IsNullOrEmpty(hash) && contents != null) ||
(!string.IsNullOrEmpty(hash) && (contents == null)));
// Check to see if the object is already in this repository.
if (this.entries.ContainsKey(obj))
{
// We shouldn't be adding conflicting information for
// the same object during the same build run.
RepositoryEntry entry = this.entries[obj];
Util.Assert(entry.Disposition.GetType() == disposition.GetType());
Util.Assert(entry.Hash.Equals(hash, StringComparison.Ordinal));
Util.Assert(entry.VirtualContents == contents);
// Don't replace existing entry with equivalent.
return;
}
this.entries[obj] = new RepositoryEntry(disposition, hash, contents);
}
private ListBoxItem GetListBoxItem([NotNull] RepositoryEntry repositoryEntry)
{
Debug.ArgumentNotNull(repositoryEntry, nameof(repositoryEntry));
var stackPanel = new StackPanel();
stackPanel.Children.Add(new TextBlock
{
Text = repositoryEntry.Name
});
stackPanel.Children.Add(new TextBlock(new Italic(new Run(repositoryEntry.Location)))
{
Margin = new Thickness(16, 0, 0, 0)
});
var listBoxItem = new ListBoxItem
{
Content = stackPanel,
Tag = repositoryEntry
};
return(listBoxItem);
}
/// <summary>
/// Gets the hash of an object registered with this Repository.
/// </summary>
/// <param name="obj">The object in question.</param>
/// <returns>
/// The hash of the object (if known), otherwise null.
/// </returns>
public string GetHash(BuildObject obj)
{
string hash = null;
RepositoryEntry value = this.GetValue(obj);
if (value != null)
{
if (value.Disposition is Failed)
{
hash = null;
}
else if (obj is VirtualBuildObject)
{
hash = "virtual";
}
else
{
hash = value.Hash;
}
}
return(hash);
}
public RepositorySource([NotNull] RepositoryEntry repositoryEntry)
{
Assert.ArgumentNotNull(repositoryEntry, nameof(repositoryEntry));
Repository = repositoryEntry;
}
private void ProcessRecordItem(RecordItem recordItem)
{
if (recordingFlushed)
{
AgentResponse agentResponse = new AgentResponse();
agentResponse.messageType = AgentResponse.MessageType.CAPTURE_STEP_REPONSE;
RanorexStepCaptureReponse captureResponse = new RanorexStepCaptureReponse();
agentResponse.stepCaptureReponse = captureResponse;
Dictionary <string, object> properties = new Dictionary <string, object>();
XmlNode parentNode = new XmlNode("recorditem");
XmlNode recordNode = recordItem.CreateXmlNode(parentNode, false);
properties.Add("attributes", recordNode.Attributes);
captureResponse.action = recordItem.DisplayName;
if (recordItem is ElementRecordItem)
{
RepositoryEntry repoEntry = ((ElementRecordItem)recordItem).GetBoundRepositoryEntry();
if (repoEntry != null)
{
string absolutePath = repoEntry.AbsolutePath.ToResolvedString();
if (absolutePath.StartsWith("/mobileapp"))
{
absolutePath = Regex.Replace(absolutePath, "/mobileapp\\[@devicename='[^\\/]*'\\]", "/mobileapp");
}
captureResponse.target = absolutePath;
}
}
if (recordItem is MouseRecordItem)
{
MouseRecordItem mouseItem = (MouseRecordItem)recordItem;
captureResponse.action = mouseItem.Action.ToString();
properties.Add("button", mouseItem.Button.ToString());
properties.Add("location", mouseItem.ElementLocation.FixedLocation.X + ";" + mouseItem.ElementLocation.FixedLocation.Y);
properties.Add("duration", 200);
captureResponse.properties = properties;
Console.WriteLine(mouseItem.Action.ToString());
Console.WriteLine((String)properties["location"]);
Console.WriteLine((String)captureResponse.target);
Debug.Print((String)mouseItem.Action.ToString());
Console.Write((String)mouseItem.Action.ToString());
agentServer.SendMessage(agentResponse);
}
else if (recordItem is KeyboardSequenceRecordItem)
{
KeyboardSequenceRecordItem sequenceItem = (KeyboardSequenceRecordItem)recordItem;
properties.Add("sequence", sequenceItem.KeySequence);
properties.Add("pressTime", 0);
properties.Add("duration", 200);
captureResponse.properties = properties;
agentServer.SendMessage(agentResponse);
}
else if (recordItem is KeyboardRecordItem)
{
KeyboardRecordItem keyboardItem = (KeyboardRecordItem)recordItem;
properties.Add("data", keyboardItem.KeyData.ToString());
properties.Add("scanCode", keyboardItem.ScanCode);
properties.Add("setModifiers", keyboardItem.SetModifiers);
properties.Add("pressTime", 0);
properties.Add("duration", 200);
captureResponse.properties = properties;
agentServer.SendMessage(agentResponse);
}
else if (recordItem is MouseWheelRecordItem)
{
MouseWheelRecordItem wheelItem = (MouseWheelRecordItem)recordItem;
string orientation = wheelItem.Orientation.ToString();
properties.Add("orientation", orientation);
properties.Add("delta", wheelItem.Delta);
properties.Add("duration", 200);
captureResponse.properties = properties;
agentServer.SendMessage(agentResponse);
}
else if (recordItem is SetValueRecordItem)
{
SetValueRecordItem setValueItem = (SetValueRecordItem)recordItem;
properties.Add("name", setValueItem.AttributeName);
properties.Add("value", setValueItem.AttributeValue);
captureResponse.properties = properties;
agentServer.SendMessage(agentResponse);
}
else if (recordItem is ElementRecordItem)
{
ElementRecordItem elementItem = (ElementRecordItem)recordItem;
captureResponse.properties = properties;
agentServer.SendMessage(agentResponse);
}
}
}
protected override void Process(InitializationPipeline pipeline)
{
Debug.ArgumentNotNull(pipeline, nameof(pipeline));
if (!pipeline.IsStartUp)
{
return;
}
RepositoryManager.Register(RepositoryManager.LicenseFiles);
RepositoryManager.Register(RepositoryManager.Packages);
RepositoryManager.Register(RepositoryManager.Reports);
RepositoryManager.Register(RepositoryManager.SitecoreZip);
RepositoryManager.Register(RepositoryManager.StartPages);
RepositoryManager.Register(RepositoryManager.Folders);
var zipFiles = RepositoryManager.GetRepository(RepositoryManager.SitecoreZip);
if (!zipFiles.Entries.Any())
{
var location = Path.Combine(AppHost.User.UserFolder, @"Repositories\SitecoreZipFiles");
Directory.CreateDirectory(location);
var repository = new RepositoryEntry("Sitecore Zip Files", location);
zipFiles.Entries.Add(repository);
zipFiles.Save();
}
var licenseFiles = RepositoryManager.GetRepository(RepositoryManager.LicenseFiles);
if (!licenseFiles.Entries.Any())
{
var location = Path.Combine(AppHost.User.UserFolder, @"Repositories\LicenseFiles");
Directory.CreateDirectory(location);
var repository = new RepositoryEntry("License Files", location);
licenseFiles.Entries.Add(repository);
licenseFiles.Save();
}
var packages = RepositoryManager.GetRepository(RepositoryManager.Packages);
if (!packages.Entries.Any())
{
var location = Path.Combine(AppHost.User.UserFolder, @"Repositories\Packages");
Directory.CreateDirectory(location);
var repository = new RepositoryEntry("Local Packages", location);
packages.Entries.Add(repository);
packages.Save();
}
var startPages = RepositoryManager.GetRepository(RepositoryManager.StartPages);
if (!startPages.Entries.Any())
{
var location = Path.Combine(AppHost.User.UserFolder, @"Repositories\StartPages");
Directory.CreateDirectory(location);
var repository = new RepositoryEntry("Start Pages", location);
startPages.Entries.Add(repository);
startPages.Save();
}
var reports = RepositoryManager.GetRepository(RepositoryManager.Reports);
if (!reports.Entries.Any())
{
var location = Path.Combine(AppHost.User.UserFolder, @"Repositories\Reports");
Directory.CreateDirectory(location);
var repository = new RepositoryEntry("Reports", location);
reports.Entries.Add(repository);
reports.Save();
}
var folders = RepositoryManager.GetRepository(RepositoryManager.Folders);
if (!folders.Entries.Any())
{
var combine = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? string.Empty, @"Repositories\Folders");
Directory.CreateDirectory(combine);
var repository = new RepositoryEntry("Default", @".\Repositories\Folders");
folders.Entries.Add(repository);
folders.Save();
}
}
// DELETE api/bookmarks/5
public void Delete(int id)
{
RepositoryEntry item = this.Get(id);
this.BookmarksRepository.Remove(item);
}
// PUT api/bookmarks/5
public void Put(int id, [FromBody] RepositoryEntry item)
{
this.BookmarksRepository.Update(item);
}
// POST api/bookmarks
public void Post([FromBody] RepositoryEntry item)
{
this.BookmarksRepository.Add(item);
}
private bool UpdateRepository(RepositoryEntry data, Reporter reporter, TransferRepository repository, string commitInfo, Stream repozip)
{
Log.Info("Try Update Repository");
UpdateLock.EnterWriteLock();
try
{
var downloadCompled = false;
var repoConfiguration = new RepositoryConfiguration(reporter, data);
using var repoPath = RepoEnv.TempFiles.CreateDic();
var data2 = _repos.AsQueryable().FirstOrDefault(r => r.RepoName == repository.RepoName);
if (data2 != null && commitInfo != data2.LastUpdate)
{
if (!string.IsNullOrWhiteSpace(data.FileName))
{
try
{
Log.Info("Downloading Repository {Name} From Server", repository.RepoName);
reporter.Send(RepositoryMessages.GetRepositoryFromDatabase);
_bucket.DownloadToStream(ObjectId.Parse(data.FileName), repozip);
downloadCompled = true;
}
catch (Exception e)
{
Log.Error(e, "Error on Download Repo File {Name}", data.FileName);
}
}
if (downloadCompled)
{
Log.Info("Unpack Repository {Name}", repository.RepoName);
repozip.Seek(0, SeekOrigin.Begin);
using var unpackZip = new ZipArchive(repozip);
reporter.Send(RepositoryMessages.ExtractRepository);
unpackZip.ExtractToDirectory(repoPath.FullPath);
}
Log.Info("Execute Git Pull for {Name}", repository.RepoName);
using var updater = GitUpdater.GetOrNew(repoConfiguration);
var result = updater.RunUpdate(repoPath.FullPath);
var dataUpdate = Builders <RepositoryEntry> .Update.Set(e => e.LastUpdate, result.Sha);
Log.Info("Compress Repository {Name}", repository.RepoName);
reporter.Send(RepositoryMessages.CompressRepository);
if (repozip.Length != 0)
{
repozip.SetLength(0);
}
using (var archive = new ZipArchive(repozip, ZipArchiveMode.Create, true))
archive.AddFilesFromDictionary(repoPath.FullPath);
repozip.Seek(0, SeekOrigin.Begin);
Log.Info("Upload and Update Repository {Name}", repository.RepoName);
reporter.Send(RepositoryMessages.UploadRepositoryToDatabase);
var current = data.FileName;
var id = _bucket.UploadFromStream(repository.RepoName.Replace('/', '_') + ".zip", repozip);
dataUpdate = dataUpdate.Set(e => e.FileName, id.ToString());
if (!string.IsNullOrWhiteSpace(current))
{
_revisions.InsertOne(new ToDeleteRevision(current));
}
_repos.UpdateOne(e => e.RepoName == data.RepoName, dataUpdate);
data.FileName = id.ToString();
repozip.Seek(0, SeekOrigin.Begin);
return(true);
}
}
finally
{
UpdateLock.ExitWriteLock();
}
return(false);
}
public RepositoryConfiguration(Reporter?logger, RepositoryEntry entry)
{
Logger = logger;
CloneUrl = entry.SourceUrl;
}
private void RegisterRepository(RegisterRepository repository, Reporter reporter)
{
UpdateLock.EnterUpgradeableReadLock();
try
{
Log.Info("Incomming Registration Request for Repository {Name}", repository.RepoName);
reporter.Send(RepositoryMessages.GetRepo);
var data = _repos.AsQueryable().FirstOrDefault(e => e.RepoName == repository.RepoName);
if (data != null)
{
Log.Info("Repository {Name} is Registrated", repository.RepoName);
if (repository.IgnoreDuplicate)
{
reporter.Compled(OperationResult.Success());
return;
}
reporter.Compled(OperationResult.Failure(RepoErrorCodes.DuplicateRepository));
return;
}
if (!repository.RepoName.Contains('/'))
{
Log.Info("Repository {Name} Name is Invalid", repository.RepoName);
reporter.Compled(OperationResult.Failure(RepoErrorCodes.InvalidRepoName));
return;
}
var nameSplit = repository.RepoName.Split('/');
var repoInfo = _gitHubClient.Repository.Get(nameSplit[0], nameSplit[1]).Result;
if (repoInfo == null)
{
Log.Info("Repository {Name} Name not found on Github", repository.RepoName);
reporter.Compled(OperationResult.Failure(RepoErrorCodes.GithubNoRepoFound));
return;
}
Log.Info("Savin new Repository {Name} on Database", repository.RepoName);
data = new RepositoryEntry
{
RepoName = repository.RepoName,
SourceUrl = repoInfo.CloneUrl,
RepoId = repoInfo.Id
};
UpdateLock.EnterWriteLock();
try
{
_repos.InsertOne(data);
}
finally
{
UpdateLock.ExitWriteLock();
}
reporter.Compled(OperationResult.Success());
}
finally
{
UpdateLock.ExitUpgradeableReadLock();
}
}
