コード例 #1
0
        public void CannotSwitchSpaceContextWhenTheRepositoryScopeIsSpecified(RepositoryScope scope)
        {
            var repository = Substitute.For <IOctopusAsyncRepository>();

            repository.Scope.Returns(scope);
            repository.LoadRootDocument().Returns(GetRootResource());
            ITeamsRepository teamRepo      = new TeamsRepository(repository);
            Action           switchContext = () => teamRepo.UsingContext(SpaceContext.AllSpaces());

            switchContext.ShouldThrow <SpaceContextSwitchException>();
        }
コード例 #2
0
        public async Task SpaceScoped_SingleSpaceContextShouldEnrichSpaceId(string spaceId)
        {
            var client = SetupAsyncClient();
            await client.Create(Arg.Any <string>(), Arg.Do <ProjectGroupResource>(t =>
            {
                t.SpaceId.Should().Be(spaceId);
            }));

            var repo = new ProjectGroupRepository(new OctopusAsyncRepository(client, RepositoryScope.ForSpace(CreateSpaceResource(spaceId))));
            var _    = await repo.Create(new ProjectGroupResource { Name = "Test" }).ConfigureAwait(false);
        }
コード例 #3
0
        private static async Task UploadPackagesAsync()
        {
            try
            {
                var             client          = FeedzClient.Create(_apiKey);
                RepositoryScope repositoryScope = client.ScopeToRepository(_organization, _repository);

                // Load *ALL* the New Packages
                var files         = Directory.GetFiles(_path);
                var numberOfFiles = files.Count();
                var counterFiles  = 1;

                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine($"{numberOfFiles} (*.nupkg) file(s) found!");
                Console.WriteLine();

                foreach (var file in files)
                {
                    Console.ForegroundColor = ConsoleColor.Cyan;
                    Console.WriteLine($"[{counterFiles}] Uploading {file}...");
                    try
                    {
                        await repositoryScope.PackageFeed.Upload(file);

                        Console.ForegroundColor = ConsoleColor.Green;
                        Console.WriteLine($"{file} correctly uploaded!");
                        Console.WriteLine();
                    }
                    catch (Exception ex)
                    {
                        Console.ForegroundColor = ConsoleColor.Red;
                        Console.WriteLine(ex.Message);
                        if (ex.Message == "Forbidden")
                        {
                            Console.WriteLine("Please, check the API Key to access and write into your own repo");
                        }
                        Console.WriteLine();
                        Console.ResetColor();
                    }
                    counterFiles += 1;
                }

                Console.ResetColor();
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("An error ocurred!");
                Console.WriteLine(ex.Message);
                Console.WriteLine();
                Console.ResetColor();
            }
        }
コード例 #4
0
        public async Task NonSingleSpaceContextShouldNotChangeExistingSpaceId(string spaceIdsToUse, bool includeSystem)
        {
            var spaceIds = spaceIdsToUse.Split(',');
            var client   = SetupAsyncClient();
            await client.Create(Arg.Any <string>(), Arg.Do <TeamResource>(t => t.SpaceId.Should().Be("Spaces-4"))).ConfigureAwait(false);

            var teamRepo    = new TeamsRepository(new OctopusAsyncRepository(client, RepositoryScope.Unspecified()));
            var multiScoped = teamRepo.UsingContext(SpaceContext.SpecificSpacesAndSystem(spaceIds.Select(CreateSpaceResource)));
            var _           = await multiScoped.Create(new TeamResource()
            {
                Name = "Test", SpaceId = "Spaces-4"
            }).ConfigureAwait(false);
        }
コード例 #5
0
        public async Task MixedScoped_SingleSpaceContextShouldEnrichSpaceId(string spaceId)
        {
            var client = SetupAsyncClient();
            await client.Create(Arg.Any <string>(), Arg.Do <TeamResource>(t =>
            {
                t.SpaceId.Should().Be(spaceId);
            })).ConfigureAwait(false);

            var teamRepo = new TeamsRepository(new OctopusAsyncRepository(client, RepositoryScope.ForSpace(CreateSpaceResource(spaceId))));
            var created  = await teamRepo.Create(new TeamResource()
            {
                Name = "Test"
            }).ConfigureAwait(false);
        }
コード例 #6
0
        public async Task NonSingleSpaceContextShouldNotEnrichSpaceId(string includingSpaceId, bool includeSystem)
        {
            var client = SetupAsyncClient();
            await client.Create(Arg.Any <string>(), Arg.Do <TeamResource>(t =>
            {
                t.SpaceId.Should().BeNullOrEmpty();
            })).ConfigureAwait(false);

            var includingSpaceContext = includeSystem ? SpaceContext.SpecificSpaceAndSystem(CreateSpaceResource(includingSpaceId)) : SpaceContext.SpecificSpace(CreateSpaceResource(includingSpaceId));
            var teamRepo    = new TeamsRepository(new OctopusAsyncRepository(client, RepositoryScope.Unspecified()));
            var multiScoped = teamRepo.UsingContext(includingSpaceContext);
            var _           = await multiScoped.Create(new TeamResource()
            {
                Name = "Test"
            }).ConfigureAwait(false);
        }
コード例 #7
0
        public ICollection <IRepository> TryGetEnabledRepos(RepositoryScope scope)
        {
            var repos = new List <IRepository>();

            if ((scope & RepositoryScope.Cache) == RepositoryScope.Cache)
            {
                repos.AddRange(GetCacheRepos());
            }

            if ((scope & RepositoryScope.Standard) == RepositoryScope.Standard)
            {
                repos.AddRange(GetStandardRepos());
            }

            return(repos);
        }
コード例 #8
0
        public async Task Can_get_by_id_not_found()
        {
            // Arrange
            const int notFoundId = 11;

            Preconditions.EnsureRandomFake();

            // Act
            FakeAggregateRoot actual;

            using (RepositoryScope scope = CreateScope())
            {
                actual = await scope
                         .Repository
                         .GetByIdAsync(
                    notFoundId,
                    _cancellationToken);
            }

            // Assert
            actual.ShouldBeNull();
        }
コード例 #9
0
        public async Task Can_get_all()
        {
            // Arrange
            Preconditions.EnsureFakes(10);
            List <FakeAggregateRoot> expected = DbContext
                                                .FakeAggregateRoots
                                                .ToList();

            // Act
            List <FakeAggregateRoot> actual;

            using (RepositoryScope scope = CreateScope())
            {
                actual = (await scope.Repository.GetAllAsync(_cancellationToken))
                         ?.ToList();
            }

            // Assert
            actual.ShouldNotBeNull();
            actual.Count.ShouldBe(expected.Count);
            actual.SequenceEqual(expected).ShouldBeTrue();
        }
コード例 #10
0
        public async Task Can_add()
        {
            // Arrange
            var newFakeAggregateRoot = new FakeAggregateRoot("expectedName");

            // Act
            int actual;

            using (RepositoryScope scope = CreateScope())
            {
                actual = await scope
                         .Repository
                         .AddAsync(newFakeAggregateRoot, _cancellationToken);
            }

            // Assert
            FakeAggregateRoot expected = await DbContext
                                         .FakeAggregateRoots
                                         .FirstAsync(f => f.Name == newFakeAggregateRoot.Name);

            actual.ShouldBe(expected.Id);
        }
コード例 #11
0
        public override async Task Execute(string[] commandLineArguments)
        {
            var remainingArguments = Options.Parse(commandLineArguments);

            if (printHelp)
            {
                GetHelp(Console.Out, commandLineArguments);

                return;
            }

            if (remainingArguments.Count > 0)
            {
                throw new CommandException("Unrecognized command arguments: " + string.Join(", ", remainingArguments));
            }

            if (string.IsNullOrWhiteSpace(ServerBaseUrl))
            {
                throw new CommandException("Please specify the Octopus Server URL using --server=http://your-server/. " +
                                           $"The Octopus Server URL can also be set in the {ServerUrlEnvVar} environment variable.");
            }

            if (!string.IsNullOrWhiteSpace(ApiKey) && !string.IsNullOrWhiteSpace(Username))
            {
                throw new CommandException("Please provide an API Key OR a username and password, not both. " +
                                           "These values may have been passed in as command line arguments, or may have been set in the " +
                                           $"{ApiKeyEnvVar} and {UsernameEnvVar} environment variables.");
            }

            if (string.IsNullOrWhiteSpace(ApiKey) && string.IsNullOrWhiteSpace(Username))
            {
                throw new CommandException("Please specify your API key using --apiKey=ABCDEF123456789 OR a username and password. " +
                                           $"The API key can also be set in the {ApiKeyEnvVar} environment variable, " +
                                           $"while the username and password can be set in the {UsernameEnvVar} and {PasswordEnvVar} " +
                                           "environment variables respectively. Learn more at: https://github.com/OctopusDeploy/Octopus-Tools");
            }

            var endpoint = string.IsNullOrWhiteSpace(ApiKey)
                ? new OctopusServerEndpoint(ServerBaseUrl)
                : new OctopusServerEndpoint(ServerBaseUrl, ApiKey);

#if NETFRAMEWORK
            /*
             * There may be a delay between the completion of a large file upload and when Octopus responds
             * to finish the HTTP connection. This delay can be several minutes. During this time, no traffic is
             * sent, and some networking infrastructure will close the connection. For example, Azure VMs will
             * close idle connections after 4 minutes, and AWS VMs will close them after 350 seconds. The
             * TCP keepalive option will ensure that the connection is not idle at the end of the file upload.
             *
             * This is the bug that explains why this doesn't work with .NET Core:
             * https://github.com/dotnet/corefx/issues/26013
             */
            if (keepAlive > 0)
            {
                ServicePointManager.FindServicePoint(new Uri(ServerBaseUrl)).SetTcpKeepAlive(true, keepAlive, keepAlive);
            }
#endif

#if HTTP_CLIENT_SUPPORTS_SSL_OPTIONS
            clientOptions.IgnoreSslErrors = ignoreSslErrors;
#else
            ServicePointManager.ServerCertificateValidationCallback = ServerCertificateValidationCallback;
#endif

            commandOutputProvider.PrintMessages = OutputFormat == OutputFormat.Default || enableDebugging;
            CliSerilogLogProvider.PrintMessages = commandOutputProvider.PrintMessages;
            commandOutputProvider.PrintHeader();

            var client = await clientFactory.CreateAsyncClient(endpoint, clientOptions).ConfigureAwait(false);

            if (!string.IsNullOrWhiteSpace(Username))
            {
                await client.Repository.Users.SignIn(Username, Password).ConfigureAwait(false);
            }

            var serverHasSpaces = await client.ForSystem().HasLink("Spaces").ConfigureAwait(false);

            if (!string.IsNullOrEmpty(spaceNameOrId))
            {
                if (!serverHasSpaces)
                {
                    throw new CommandException($"The server {endpoint.OctopusServer} has no spaces. Try invoking {AssemblyExtensions.GetExecutableName()} without specifying the space name as an argument");
                }

                var space = await client.ForSystem().Spaces.FindByNameOrIdOrFail(spaceNameOrId).ConfigureAwait(false);

                Repository = repositoryFactory.CreateRepository(client, RepositoryScope.ForSpace(space));
                commandOutputProvider.Debug("Space name specified, process is now running in the context of space: {space:l}", space.Name);
            }
            else
            {
                Repository = repositoryFactory.CreateRepository(client);

                if (!serverHasSpaces)
                {
                    commandOutputProvider.Debug("Process will run in backwards compatible mode for older versions of Octopus Server");
                }
                else
                {
                    var defaultSpace = await client.ForSystem()
                                       .Spaces.FindOne(space => space.IsDefault)
                                       .ConfigureAwait(false);

                    if (defaultSpace == null)
                    {
                        throw new CommandException("Octopus Server does not have a default space enabled, hence you need to specify the space name as an argument");
                    }

                    commandOutputProvider.Debug("Space name unspecified, process will run in the default space context");
                }
            }

            RepositoryCommonQueries = new OctopusRepositoryCommonQueries(Repository, commandOutputProvider);

            if (enableDebugging)
            {
                Repository.Client.SendingOctopusRequest += request => commandOutputProvider.Debug("{Method:l} {Uri:l}", request.Method, request.Uri);
            }

            commandOutputProvider.Debug("Handshaking with Octopus Server: {Url:l}", ServerBaseUrl);

            var root = await Repository.LoadRootDocument().ConfigureAwait(false);

            commandOutputProvider.Debug("Handshake successful. Octopus version: {Version:l}; API version: {ApiVersion:l}", root.Version, root.ApiVersion);

            var user = await Repository.Users.GetCurrent().ConfigureAwait(false);

            if (user != null)
            {
                if (string.IsNullOrEmpty(user.EmailAddress))
                {
                    commandOutputProvider.Debug("Authenticated as: {Name:l} {IsService:l}", user.DisplayName, user.IsService ? "(a service account)" : "");
                }
                else
                {
                    commandOutputProvider.Debug("Authenticated as: {Name:l} <{EmailAddress:l}> {IsService:l}", user.DisplayName, user.EmailAddress, user.IsService ? "(a service account)" : "");
                }
            }

            await ValidateParameters().ConfigureAwait(false);
            await Execute().ConfigureAwait(false);
        }
コード例 #12
0
        /// <summary>
        /// Ricerca fulltext nell'oggetto document
        ///
        /// nb: da fare anche ricerca allegati
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public ArrayList FullTextSearch(ref FullTextSearchContext context)
        {
            ArrayList result = new ArrayList();

            try
            {
                List <string> fullTextResult = null;

                if (context.SearchResultList != null && context.SearchResultList.Length > 0)
                {
                    // Ricerca già effettuata, reperimento dall'oggetto di contesto
                    // dei risultati precedenti evitando così una dispendiosa
                    // chiamata al sistema documentale
                    fullTextResult = new List <string>(context.SearchResultList);
                }
                else
                {
                    StructuredQuery strQuery = new StructuredQuery();

                    strQuery.AddRepository(DctmConfigurations.GetRepositoryName());
                    strQuery.ObjectType = ObjectTypes.DOCUMENTO;

                    strQuery.IsDatabaseSearch     = false;
                    strQuery.IsIncludeAllVersions = false;
                    strQuery.IsIncludeHidden      = false;

                    // Inserisce nella ricerca il solo cabinet dell'amministrazione
                    RepositoryScope repositoryScope = new RepositoryScope();
                    repositoryScope.RepositoryName = DctmConfigurations.GetRepositoryName();
                    repositoryScope.LocationPath   = DocsPaAdminCabinet.getRootAmministrazione(this.InfoUtente);
                    repositoryScope.IsDescend      = true;
                    strQuery.Scopes.Add(repositoryScope);

                    ExpressionSet set = new ExpressionSet();
                    set.AddExpression(new FullTextExpression(context.TextToSearch));
                    strQuery.RootExpressionSet = set;

                    // Query execution
                    int            startIndex = (context.RequestedPageNumber * PAGE_SIZE) - PAGE_SIZE;
                    int            maxResults = this.GetMaxRowCount();
                    QueryExecution queryExec  = new QueryExecution(startIndex, maxResults, maxResults);

                    ISearchService searchService = DctmServiceFactory.GetServiceInstance <ISearchService>(this.InfoUtente.dst);
                    QueryResult    queryResult   = searchService.Execute(strQuery, queryExec, null);

                    QueryStatus          queryStatus   = queryResult.QueryStatus;
                    RepositoryStatusInfo repStatusInfo = queryResult.QueryStatus.RepositoryStatusInfos[0];

                    if (repStatusInfo.Status == Status.FAILURE)
                    {
                        throw new ApplicationException("QueryResult: Status.FAILURE");
                    }

                    fullTextResult = new List <string>();

                    foreach (DataObject dataObject in queryResult.DataObjects)
                    {
                        // Reperimento docnumber
                        string docNumber = dataObject.Properties.Get(TypeDocumento.DOC_NUMBER).GetValueAsString();

                        if (!fullTextResult.Contains(docNumber)) // Eliminazione dei risultati duplicati
                        {
                            fullTextResult.Add(docNumber);
                        }
                    }

                    context.SearchResultList = fullTextResult.ToArray();
                    context.TotalPageNumber  = (fullTextResult.Count / PAGE_SIZE);
                    context.TotalRecordCount = fullTextResult.Count;
                }

                // Paginazione dei risultati
                if (fullTextResult != null && fullTextResult.Count > 0)
                {
                    int startIndex = (context.RequestedPageNumber * PAGE_SIZE) - PAGE_SIZE;
                    int count      = PAGE_SIZE;
                    if (fullTextResult.Count < count)
                    {
                        count = fullTextResult.Count;
                    }
                    List <string> pageContent = fullTextResult.GetRange(startIndex, count);
                    result = this.GetDocuments(pageContent.ToArray(), InfoUtente);
                }
            }
            catch (Exception ex)
            {
                result.Clear();
                logger.Debug(string.Format("Errore in Documentum.FullTextSearch:\n{0}", ex.ToString()));
            }

            return(result);
        }
コード例 #13
0
        private void Install(IResolutionResult resolutionResult, PackageManifestRoot manifest, RepositoryScope scope)
        {
            if (scope != RepositoryScope.Cache)
            {
                var cacheRepo = new CacheRepository(_repositoryFactory.TryGetEnabledRepos(RepositoryScope.Cache));
                cacheRepo.PackageDownloadToCacheRepositoryStarted  += CacheRepositoryPackageDownloadToCacheRepositoryStarted;
                cacheRepo.PackageDownloadToCacheRepositoryFinished += CacheRepositoryOnPackageDownloadToCacheRepositoryFinished;

                cacheRepo.DownloadLocally(resolutionResult.ResolutionTable.GetSatisfyingInfos());

                cacheRepo.PackageDownloadToCacheRepositoryStarted  -= CacheRepositoryPackageDownloadToCacheRepositoryStarted;
                cacheRepo.PackageDownloadToCacheRepositoryFinished -= CacheRepositoryOnPackageDownloadToCacheRepositoryFinished;
            }

            using (var installer = _packageInstallerFactory.GetInstaller(_manifestResolver.CurrentDirectory, resolutionResult.ResolutionTable, manifest))
            {
                installer.BeginInstallPackage  += BeginInstallPackage;
                installer.FinishInstallPackage += FinishInstallPackage;

                if (Force)
                {
                    _writer.Text($"Reinstalling {resolutionResult.ResolutionTable.GetPackages().Count()} packages... ");
                    installer.Reinstall(Configuration);
                }
                else
                {
                    var diff = installer.GetDiffWithCurrent(resolutionResult.ResolutionTable.GetSatisfyingInfos()).ToArray();

                    int changed = PrintSuccess(diff);
                    if (changed > 0)
                    {
                        installer.Upgrade(Configuration, diff);
                    }
                    else
                    {
                        _writer.Success("No changes detected");
                    }
                }

                installer.BeginInstallPackage  -= BeginInstallPackage;
                installer.FinishInstallPackage -= FinishInstallPackage;
            }
        }
コード例 #14
0
        public TreeModel GetTree(string path)
        {
            var    isEmptyPath = string.IsNullOrEmpty(path);
            string referenceName;
            var    commit = GetCommitByPath(ref path, out referenceName);

            if (commit == null)
            {
                if (isEmptyPath)
                {
                    var branch = _repository.Branches["master"]
                                 ?? _repository.Branches.FirstOrDefault();
                    return(new TreeModel
                    {
                        ReferenceName = branch == null ? "HEAD" : branch.Name,
                    });
                }
                return(null);
            }

            var model = new TreeModel
            {
                ReferenceName = referenceName,
                Path          = string.IsNullOrEmpty(path) ? "" : path,
                Commit        = new CommitModel
                {
                    Sha                = commit.Sha,
                    Author             = commit.Author,
                    Committer          = commit.Committer,
                    CommitMessageShort = commit.MessageShort.RepetitionIfEmpty(NoCommitMessage),
                    Parents            = commit.Parents.Select(s => s.Sha).ToArray()
                },
            };

            var tree = string.IsNullOrEmpty(path)
                ? commit.Tree
                : commit[path] == null
                    ? null
                    : commit[path].Target as Tree;

            if (tree == null)
            {
                return(null);
            }

            IEnumerable <Commit> ancestors = _repository.Commits
                                             .QueryBy(new CommitFilter {
                Since = commit, SortBy = CommitSortStrategies.Topological
            });

            var scope = GitCache.Get <RepositoryScope>(commit.Sha, "scope");

            if (scope == null)
            {
                ancestors = ancestors.ToList();
                scope     = new RepositoryScope
                {
                    Commits      = ancestors.Count(),
                    Contributors = ancestors.Select(s => s.Author.ToString()).Distinct().Count(),
                };
                GitCache.Set(commit.Sha, "scope", scope);
            }

            var entries = tree
                          .OrderBy(s => s.TargetType == TreeEntryTargetType.Blob)
                          .ThenBy(s => s.Name, new StringLogicalComparer())
                          .Select(s => new TreeEntryModel
            {
                Name          = s.Name,
                ReferenceName = referenceName,
                Path          = s.Path.Replace('\\', '/'),
                Commit        = new CommitModel
                {
                    CommitMessageShort = "???",
                    Author             = new Signature("???", "???", DateTimeOffset.MinValue),
                },
                Sha       = s.Target.Sha,
                EntryType = s.TargetType,
            })
                          .ToList();

            var    summary = GitCache.Get <RevisionSummaryCacheItem[]>(tree.Sha, "summary");
            var    missing = summary == null;
            double scale   = scope.Commits * tree.Count;

            if ((missing || summary.Length == 0) && scale > 20000)
            {
                LazyLoadTree(entries, commit, path, scale);
            }
            else
            {
                summary = CalculateRevisionSummary(entries, ancestors, summary);
            }

            if (missing)
            {
                GitCache.Set(tree.Sha, "summary", summary ?? new RevisionSummaryCacheItem[0]);
            }

            model.Entries = entries;
            model.Readme  = entries.FirstOrDefault(s => s.EntryType == TreeEntryTargetType.Blob &&
                                                   (string.Equals(s.Name, "readme", StringComparison.OrdinalIgnoreCase)
                                                    //|| string.Equals(s.Name, "readme.txt", StringComparison.OrdinalIgnoreCase)
                                                    || string.Equals(s.Name, "readme.md", StringComparison.OrdinalIgnoreCase)));

            if (model.Readme != null)
            {
                var data     = ((Blob)tree[model.Readme.Name].Target).GetContentStream().ToBytes();
                var encoding = FileHelper.DetectEncoding(data, CpToEncoding(commit.Encoding), _i18n.Value);
                if (encoding == null)
                {
                    model.Readme.BlobType = BlobType.Binary;
                }
                else
                {
                    model.Readme.BlobType = model.Readme.Name.EndsWith(".md", StringComparison.OrdinalIgnoreCase)
                        ? BlobType.MarkDown
                        : BlobType.Text;
                    model.Readme.TextContent = FileHelper.ReadToEnd(data, encoding);
                    model.Readme.TextBrush   = "no-highlight";
                }
            }

            model.BranchSelector = GetBranchSelectorModel(referenceName, commit.Sha, path);
            model.PathBar        = new PathBarModel
            {
                Name          = Name,
                Action        = "Tree",
                Path          = path,
                ReferenceName = referenceName,
                ReferenceSha  = commit.Sha,
                HideLastSlash = false,
            };

            if (model.IsRoot)
            {
                scope.Branches = _repository.Branches.Count();
                scope.Tags     = _repository.Tags.Count();
                model.Scope    = scope;
            }

            return(model);
        }