Ejemplo n.º 1
0
 public GitInstallationState(IGitEnvironment currentEnvironment)
 {
     GitInstallationPath    = currentEnvironment.GitInstallationPath;
     GitExecutablePath      = currentEnvironment.GitExecutablePath;
     GitLfsInstallationPath = currentEnvironment.GitLfsInstallationPath;
     GitLfsExecutablePath   = currentEnvironment.GitLfsExecutablePath;
 }
Ejemplo n.º 2
0
        public ProcessEnvironment(IProcessEnvironment defaultEnvironment, IGitEnvironment environment)
        {
            this.defaultEnvironment = defaultEnvironment;
            GitEnvironment          = environment;

            Logger = LogHelper.GetLogger(GetType());
        }
Ejemplo n.º 3
0
 public Platform(IGitEnvironment environment)
 {
     Environment    = environment;
     TaskManager    = new TaskManager();
     ProcessManager = new GitProcessManager(Environment);
     GitClient      = new GitClient(this);
     Instance       = this;
 }
Ejemplo n.º 4
0
        public TestData(string testName, ILogging logger, string testRepoName = null, bool withHttpServer = false,
                        ICacheContainer cacheContainer = null,
                        IFileSystem fileSystem         = null)
        {
            TestName         = testName;
            Logger           = logger;
            Watch            = new Stopwatch();
            SourceDirectory  = TestContext.CurrentContext.TestDirectory.ToSPath();
            TestPath         = SPath.CreateTempDirectory(testName);
            SPath.FileSystem = fileSystem ?? new FileSystem(TestPath);

            if (cacheContainer == null)
            {
                var container = new CacheContainer();
                container.SetCacheInitializer(CacheType.Branches, () => BranchesCache.Instance);
                container.SetCacheInitializer(CacheType.GitAheadBehind, () => GitAheadBehindCache.Instance);
                container.SetCacheInitializer(CacheType.GitLocks, () => GitLocksCache.Instance);
                container.SetCacheInitializer(CacheType.GitLog, () => GitLogCache.Instance);
                container.SetCacheInitializer(CacheType.GitStatus, () => GitStatusCache.Instance);
                container.SetCacheInitializer(CacheType.GitUser, () => GitUserCache.Instance);
                container.SetCacheInitializer(CacheType.RepositoryInfo, () => RepositoryInfoCache.Instance);
                cacheContainer = container;
            }


            Environment = new IntegrationTestEnvironment(cacheContainer, TestPath, TestPath.Parent, testName);
            InitializeEnvironment(testRepoName);

            ApplicationManager = new ApplicationManagerBase(new MainThreadSynchronizationContext(), Environment);

            if (testRepoName != null)
            {
                var testZipFilePath = SourceDirectory.Combine("IOTestsRepo.zip");
                ZipHelper.Instance.Extract(testZipFilePath, TestPath, (_, __) => { }, (value, total, name) => true, token: TaskManager.Token);
                TestRepo = new TestRepoData(this, testRepoName);

                InstallTestGit();
                InitializeRepository();
            }

#if NUNIT
            if (withHttpServer)
            {
                var filesToServePath = SourceDirectory.Combine("files");
                HttpServer = new HttpServer(filesToServePath, 0);
                var started = new ManualResetEventSlim();
                var task    = TaskManager.With(HttpServer.Start, TaskAffinity.None);
                task.OnStart += _ => started.Set();
                task.Start();
                started.Wait();
            }
#endif
            ((ApplicationManagerBase)ApplicationManager).Initialize();

            Logger.Trace($"START {testName}");
            Watch.Start();
        }
Ejemplo n.º 5
0
        public ApplicationManager(IMainThreadSynchronizationContext synchronizationContext,
                                  IGitEnvironment environment)
            : base(synchronizationContext as SynchronizationContext, environment)
        {
            FirstRun   = ApplicationCache.Instance.FirstRun;
            InstanceId = ApplicationCache.Instance.InstanceId;

            ListenToUnityExit();
            Initialize();
        }
Ejemplo n.º 6
0
 public GitInstaller(IGitEnvironment environment, IProcessManager processManager,
                     CancellationToken token,
                     GitInstallationState state       = null,
                     GitInstallDetails installDetails = null)
     : base(token)
 {
     this.environment             = environment;
     this.processManager          = processManager;
     this.state                   = state;
     this.sharpZipLibHelper       = ZipHelper.Instance;
     this.installDetails          = installDetails ?? new GitInstallDetails(environment.UserCachePath, environment);
     progressReporter.OnProgress += progress.UpdateProgress;
 }
Ejemplo n.º 7
0
        public static Package Load(ITaskManager taskManager, IGitEnvironment environment, UriString packageFeed)
        {
            Package package = null;

            var filename = packageFeed.Filename.ToSPath();

            if (!filename.IsInitialized || filename.IsRoot)
            {
                return(package);
            }

            var key  = filename.FileNameWithoutExtension + "_updatelastCheckTime";
            var now  = DateTimeOffset.Now;
            var feed = environment.UserCachePath.Combine(packageFeed.Filename);

            if (!feed.FileExists() || now.Date > environment.UserSettings.Get <DateTimeOffset>(key).Date)
            {
                feed = new DownloadTask(taskManager, packageFeed, environment.UserCachePath)
                       .Catch(ex =>
                {
                    Logger.Warning(@"Error downloading package feed:{0} ""{1}"" Message:""{2}""", packageFeed, ex.GetType().ToString(), ex.GetExceptionMessageShort());
                    return(true);
                })
                       .RunSynchronously().ToSPath();

                if (feed.IsInitialized)
                {
                    environment.UserSettings.Set <DateTimeOffset>(key, now);
                }
            }

            if (!feed.IsInitialized)
            {
                // try from assembly resources
                feed = AssemblyResources.ToFile(ResourceType.Platform, packageFeed.Filename, environment.UserCachePath, environment);
            }

            if (feed.IsInitialized)
            {
                try
                {
                    package = feed.ReadAllText().FromJson <Package>(true, false);
                }
                catch (Exception ex)
                {
                    Logger.Error(ex);
                }
            }
            return(package);
        }
Ejemplo n.º 8
0
        private static IEnumerable <string> CreateEnvPath(IGitEnvironment environment, SPath basePath)
        {
            yield return(environment.GitExecutablePath.Parent.ToString());

            yield return(basePath.Combine("bin").ToString());

            if (environment.IsWindows)
            {
                yield return(environment.GitInstallPath.Combine("usr/bin").ToString());
            }
            if (environment.GitInstallPath.IsInitialized && environment.GitLfsExecutablePath.Parent != environment.GitExecutablePath.Parent)
            {
                yield return(environment.GitLfsExecutablePath.Parent.ToString());
            }
        }
        public static DugiteReleaseManifest Load(ITaskManager taskManager, SPath localCacheFile,
                                                 UriString packageFeed, IGitEnvironment environment,
                                                 bool alwaysDownload = false)
        {
            DugiteReleaseManifest package = null;
            var filename = localCacheFile.FileName;
            var cacheDir = localCacheFile.Parent;
            var key      = localCacheFile.FileNameWithoutExtension + "_updatelastCheckTime";
            var now      = DateTimeOffset.Now;

            if (!localCacheFile.FileExists() ||
                (alwaysDownload || now.Date > environment.UserSettings.Get <DateTimeOffset>(key).Date))
            {
                var result = new DownloadTask(taskManager, packageFeed,
                                              localCacheFile.Parent, filename)
                             .Catch(ex => {
                    Logger.Warning(@"Error downloading package feed:{0} ""{1}"" Message:""{2}""", packageFeed,
                                   ex.GetType().ToString(), ex.GetExceptionMessageShort());
                    return(true);
                }).RunSynchronously();
                localCacheFile = result.ToSPath();
                if (localCacheFile.IsInitialized && !alwaysDownload)
                {
                    environment.UserSettings.Set <DateTimeOffset>(key, now);
                }
            }

            if (!localCacheFile.IsInitialized)
            {
                // try from assembly resources
                localCacheFile = AssemblyResources.ToFile(ResourceType.Platform, filename, cacheDir, environment);
            }

            if (localCacheFile.IsInitialized)
            {
                try
                {
                    package = Load(taskManager, localCacheFile, cacheDir, environment);
                }
                catch (Exception ex)
                {
                    Logger.Error(ex);
                }
            }
            return(package);
        }
Ejemplo n.º 10
0
        public static void Initialize(IGitEnvironment env, IPlatform plat)
        {
            environment = env;
            platform    = plat;
            //platform.Keychain.ConnectionsChanged += UserMayHaveChanged;

            // we need to do this to get the initial user information up front
            //UserMayHaveChanged();

            repository = environment.Repository;
            UnityShim.Editor_finishedDefaultHeaderGUI += InspectorHeaderFinished;

            if (repository != null)
            {
                repository.LocksChanged += RepositoryOnLocksChanged;
                repository.CheckAndRaiseEventsIfCacheNewer(CacheType.GitLocks, lastLocksChangedEvent);
            }
        }
Ejemplo n.º 11
0
        private static SPath TryGetFile(ResourceType resourceType, string resource, IGitEnvironment environment)
        {
            /*
             *  This function attempts to get files embedded in the callers assembly.
             *  Unity.VersionControl.Git which tends to contain logos
             *  Git.Api which tends to contain application resources
             *
             *  Each file's name is their physical path in the project.
             *
             *  When running tests, we assume the tests are looking for application resources, and default to returning Git.Api
             *
             *  First check for the resource in the calling assembly.
             *  If the resource cannot be found, fallback to looking in Git.Api's assembly.
             *  If the resource is still not found, it attempts to find it in the file system
             */

            (string type, string os) = ParseResourceType(resourceType, environment);

            var stream = TryGetResource(resourceType, type, os, resource);

            if (stream != null)
            {
                var target = SPath.GetTempFilename();
                return(target.WriteAllBytes(stream.ToByteArray()));
            }

            SPath possiblePath = environment.ExtensionInstallPath.Combine(type, os, resource);

            if (possiblePath.FileExists())
            {
                return(possiblePath);
            }

            var basePath = resourceType == ResourceType.Icon ? "Editor" : "Api";

            possiblePath = environment.ExtensionInstallPath.Parent.Combine(basePath, type, os, resource);
            if (possiblePath.FileExists())
            {
                return(possiblePath);
            }

            return(SPath.Default);
        }
        public static DugiteReleaseManifest Load(ITaskManager taskManager, SPath manifestFile,
                                                 SPath userCachePath,
                                                 IGitEnvironment environment)
        {
            var manifest = manifestFile.ReadAllText().FromJson <DugiteReleaseManifest>(true, false);

            var(zipAsset, shaAsset) = manifest.GetAsset(environment);
            var shaAssetPath = userCachePath.Combine("downloads", shaAsset.Name);

            if (!shaAssetPath.FileExists())
            {
                var downloader = new Downloader(taskManager);
                downloader.QueueDownload(shaAsset.Url, shaAssetPath.Parent, shaAssetPath.FileName);
                downloader.RunSynchronously();
            }
            zipAsset.Hash          = shaAssetPath.ReadAllText();
            manifest.DugitePackage = zipAsset;
            return(manifest);
        }
Ejemplo n.º 13
0
        public static SPath RelativeToProject(this SPath path, IGitEnvironment environment)
        {
            path.ThrowIfNotInitialized();
            Guard.ArgumentNotNull(environment, nameof(environment));

            var projectPath    = environment.UnityProjectPath.ToSPath();
            var repositoryPath = environment.RepositoryPath;

            if (projectPath == repositoryPath)
            {
                return(path);
            }

            if (repositoryPath.IsChildOf(projectPath))
            {
                throw new InvalidOperationException($"RepositoryPath:\"{repositoryPath}\" should not be child of ProjectPath:\"{projectPath}\"");
            }

            return(repositoryPath.Combine(path).MakeAbsolute().RelativeTo(projectPath));
        }
Ejemplo n.º 14
0
 public UserSettings(IGitEnvironment environment)
 {
     SettingsPath = environment.UserCachePath.Combine(settingsFileName);
 }
Ejemplo n.º 15
0
 public GitObjectFactory(IGitEnvironment environment)
 {
     this.environment = environment;
 }
Ejemplo n.º 16
0
        public static SPath ToFile(ResourceType resourceType, string resource, SPath destinationPath, IGitEnvironment environment)
        {
            var source = TryGetFile(resourceType, resource, environment);

            if (source.IsInitialized)
            {
                return(source.Copy(destinationPath));
            }
            return(SPath.Default);
        }
Ejemplo n.º 17
0
 public HttpClient(IGitEnvironment environment)
 {
     this.client = new System.Net.Http.HttpClient();
     this.client.DefaultRequestHeaders.Add(HeaderNames.UserAgent, USER_AGENT_HEADER);
     this.client.DefaultRequestHeaders.Add(HeaderNames.Authorization, $"Basic {environment.EncodededCredentials}");
 }
Ejemplo n.º 18
0
 /// <summary>
 /// Creates an instance of the process manager and the <see cref="GitProcessEnvironment"/>.
 /// </summary>
 /// <param name="environment"></param>
 public GitProcessManager(IGitEnvironment environment) :  base(environment)
 {
     GitEnvironment        = environment;
     GitProcessEnvironment = new ProcessEnvironment(DefaultProcessEnvironment, environment);
 }
Ejemplo n.º 19
0
 public static Stream ToStream(ResourceType resourceType, string resource, IGitEnvironment environment)
 {
     return(TryGetStream(resourceType, resource, environment));
 }
Ejemplo n.º 20
0
 public LocalSettings(IGitEnvironment environment)
 {
     SettingsPath = environment.UnityProjectPath.ToSPath().Combine(RelativeSettingsPath, settingsFileName);
 }
Ejemplo n.º 21
0
 public GitProcessEnvironment(IGitEnvironment environment, SPath repositoryRoot)
     : base(environment, FindRepositoryRoot(repositoryRoot))
 {
     Instance = this;
     Reset();
 }
Ejemplo n.º 22
0
 public SystemSettings(IGitEnvironment environment)
 {
     SettingsPath = environment.SystemCachePath.Combine(settingsFileName);
 }