예제 #1
0
        public PackageMetadata GetMetadata(IPackage package)
        {
            #region Preconditions

            if (package == null)
            {
                throw new ArgumentNullException(nameof(package));
            }

            #endregion

            var metadataFile = package.Find("package.json");

            if (metadataFile == null)
            {
                throw new Exception("Missing /package.json");
            }

            return(PackageMetadata.Parse(metadataFile.OpenAsync().Result));
        }
예제 #2
0
        public void A()
        {
            var text = @"{
  ""name"": ""lefty"",
  ""version"": ""1.0.6"",
  ""dependencies"": {
    ""basejs""     : ""2.0.x"",
    ""corejs""     : ""1.6.x"",
    ""router""     : ""1.2.x"",
    ""zoomable""   : ""1.2.x"",
    ""forms""      : ""2.1.x"",
    ""lazyjs""     : ""1.2.x"",
    ""scrollable"" : ""1.2.x"",
    ""player""     : ""3.2.x"",
    
    ""app""    : ""./scripts/app.js""
  }
}";

            var metadata = PackageMetadata.Parse(text);

            Assert.Equal("lefty", metadata.Name);
            Assert.Equal(new SemanticVersion(1, 0, 6), metadata.Version);

            Assert.Equal("basejs", metadata.Dependencies[0].Name);
            Assert.Equal("corejs", metadata.Dependencies[1].Name);
            Assert.Equal("router", metadata.Dependencies[2].Name);

            Assert.Equal(SemanticVersion.Parse("2.0.0"), metadata.Dependencies[0].VersionRange.Start);
            Assert.Equal(SemanticVersion.Parse("1.6.0"), metadata.Dependencies[1].VersionRange.Start);
            Assert.Equal(SemanticVersion.Parse("1.2.0"), metadata.Dependencies[2].VersionRange.Start);

            Assert.Equal(SemanticVersion.Parse("2.0.9999"), metadata.Dependencies[0].VersionRange.End);
            Assert.Equal(SemanticVersion.Parse("1.6.9999"), metadata.Dependencies[1].VersionRange.End);
            Assert.Equal(SemanticVersion.Parse("1.2.9999"), metadata.Dependencies[2].VersionRange.End);
        }
예제 #3
0
        public async Task <WebLibrary> DeployAsync(IPackage package, RevisionSource source, int publisherId)
        {
            #region Preconditions

            if (package == null)
            {
                throw new ArgumentNullException(nameof(package));
            }

            #endregion

            var metadata = GetMetadata(package);

            var version = metadata.Version;

            // var existing = await registry.GetAsync(registry.Lookup(metadata.Name), metadata.Version);

            // if (existing != null) throw new PublishingConflict(existing);

            var mainPath = metadata.Main;

            var bowerFile = package.Find("bower.json");

            if (bowerFile != null)
            {
                try
                {
                    var bowerFileStream = await bowerFile.OpenAsync().ConfigureAwait(false);

                    var bower = PackageMetadata.Parse(bowerFileStream);

                    if (bower.Main != null)
                    {
                        mainPath = bower.Main;
                    }
                }
                catch { }
            }

            if (mainPath == null)
            {
                throw new Exception("A main property found in package.json or bower.json.");
            }

            var mainFile = package.Find(mainPath);

            if (mainFile == null)
            {
                throw new Exception($"The main file '{mainPath}' was not found");
            }

            var mainText = await mainFile.ReadAllTextAsync().ConfigureAwait(false);

            if (mainText.Length == 0)
            {
                throw new Exception($"{mainPath} is empty");
            }

            var mainBlobStream = new MemoryStream(Encoding.UTF8.GetBytes(mainText));

            var mainName = mainPath.Split('/').Last();

            if (!mainName.EndsWith(".js"))
            {
                throw new Exception($"Must end with js. was {mainName}");
            }

            var mainBlob = new Blob(
                key: $"libs/{metadata.Name}/{version}/{mainName}",
                stream: mainBlobStream,
                properties: new BlobProperties {
                ContentType = "application/javascript"
            }
                );

            var mainHash = Hash.ComputeSHA256(mainBlobStream);

            // Push to CDN
            await bucket.PutAsync(mainBlob).ConfigureAwait(false);

            if (metadata.Files != null)
            {
                // TODO: Copy over everything from files[] (excluding main)
                foreach (var fileName in metadata.Files)
                {
                    var fn = fileName;

                    if (fn.StartsWith("./"))
                    {
                        fn = fileName.Substring(2);
                    }

                    if (fn == mainPath)
                    {
                        continue;
                    }

                    var asset = package.Find(fn);

                    var format = asset.Key.Split('.').Last();

                    var n = asset.Key.Split('/').Last();

                    var ms = new MemoryStream();

                    using (var data = await asset.OpenAsync().ConfigureAwait(false))
                    {
                        data.CopyTo(ms);

                        ms.Position = 0;
                    }

                    var blob = new Blob(
                        key: $"libs/{metadata.Name}/{version}/{n}",
                        stream: ms,
                        properties: new BlobProperties {
                        ContentType = GetMime(format)
                    }
                        );

                    await bucket.PutAsync(blob).ConfigureAwait(false);
                }
            }

            var release = new WebLibrary(metadata.Name, version)
            {
                MainName   = mainName,
                MainSha256 = mainHash,
                Source     = source.ToString()
            };

            return(release);
        }