/// <summary> /// Get an archive of a given repository's contents, using a specific format and reference /// </summary> /// <remarks>https://developer.github.com/v3/repos/contents/#get-archive-link</remarks> /// <param name="owner">The owner of the repository</param> /// <param name="name">The name of the repository</param> /// <param name="archiveFormat">The format of the archive. Can be either tarball or zipball</param> /// <param name="reference">A valid Git reference.</param> public IObservable <byte[]> GetArchive(string owner, string name, ArchiveFormat archiveFormat, string reference) { Ensure.ArgumentNotNullOrEmptyString(owner, "owner"); Ensure.ArgumentNotNullOrEmptyString(name, "name"); Ensure.ArgumentNotNull(reference, "reference"); return(GetArchive(owner, name, archiveFormat, reference, TimeSpan.FromMinutes(60))); }
/// <summary> /// Get an archive of a given repository's contents, in a specific format /// </summary> /// <remarks>https://developer.github.com/v3/repos/contents/#get-archive-link</remarks> /// <param name="owner">The owner of the repository</param> /// <param name="name">The name of the repository</param> /// <param name="archiveFormat">The format of the archive. Can be either tarball or zipball</param> /// <param name="reference">A valid Git reference.</param> /// <param name="timeout"> Time span until timeout </param> /// <returns>The binary contents of the archive</returns> public IObservable<byte[]> GetArchive(string owner, string name, ArchiveFormat archiveFormat, string reference, TimeSpan timeout) { Ensure.ArgumentNotNullOrEmptyString(owner, "owner"); Ensure.ArgumentNotNullOrEmptyString(name, "name"); Ensure.GreaterThanZero(timeout, "timeout"); return _client.Repository.Content.GetArchive(owner, name, archiveFormat, reference, timeout).ToObservable(); }
public CommitLog(DateTime date, string message, Func <DateTime, string, string> filenameFormatter, ArchiveFormat format, string savedPath) { Date = date; Message = message; Filename = filenameFormatter(date, message); Format = format; SavedPath = savedPath; }
public CommitLog(DateTime date, string message, string filename, ArchiveFormat format, string savedPath) { Date = date; Message = message; Filename = filename; Format = format; SavedPath = savedPath; }
public GanFrameArchive(ArcView arc, ArchiveFormat impl, ICollection <Entry> dir) : base(arc, impl, dir) { Info = new ImageMetaData { Width = DefaultWidth, Height = DefaultHeight, BPP = 24 }; Frames = new byte[dir.Count][]; }
public NpaArchive(ArcView arc, ArchiveFormat impl, ICollection <Entry> dir, EncryptionScheme scheme, int key) : base(arc, impl, dir) { Scheme = scheme; Key = key; m_key_table = new Lazy <byte[]> (() => NpaOpener.GenerateKeyTable(scheme)); }
public Task <byte[]> GetArchive(string owner, string name, ArchiveFormat archiveFormat, string reference) { Ensure.ArgumentNotNullOrEmptyString(owner, nameof(owner)); Ensure.ArgumentNotNullOrEmptyString(name, nameof(name)); Ensure.ArgumentNotNull(reference, nameof(reference)); return(GetArchive(owner, name, archiveFormat, reference, TimeSpan.FromMinutes(60))); }
internal PscxSevenZipExtractor(PscxCmdlet command, FileInfo file, bool passThru, ArchiveFormat format) : base(command, file, format) { _passThru = passThru; _entries = new List<ArchiveEntry>(); foreach (ArchiveEntry entry in this){ _entries.Add(entry); } }
public List <Entry> Read() { byte[] packed; using (var input = m_file.CreateStream(12, m_data_offset - 12)) using (var bits = new MsbBitStream(input)) { bits.GetNextBit(); m_dict = ReadBytes(bits); if (null == m_dict) { return(null); } int packed_size = ReadInt32(bits); int unpacked_size = ReadInt32(bits); packed = new byte[packed_size]; for (int i = 0; i < packed_size; ++i) { packed[i] = (byte)bits.GetBits(8); } } using (var bstr = new BinMemoryStream(packed)) using (var zstr = new ZLibStream(bstr, CompressionMode.Decompress)) using (var index = new MsbBitStream(zstr)) { index.GetNextBit(); int count = ReadInt32(index); if (!ArchiveFormat.IsSaneCount(count)) { return(null); } var dir = new List <Entry> (count); for (int i = 0; i < count; ++i) { if (index.GetBits(2) == -1) { break; } var name_buf = ReadEncryptedChars(index); if (null == name_buf) { return(null); } var name = DecryptString(name_buf, name_buf.Length); var entry = FormatCatalog.Instance.Create <Entry> (name); ReadInt32(index); ReadInt32(index); entry.Offset = (uint)ReadInt32(index) + m_data_offset; entry.Size = (uint)ReadInt32(index); if (!entry.CheckPlacement(m_file.MaxOffset)) { return(null); } dir.Add(entry); } return(dir); } }
protected SevenZipBaseEx(PscxCmdlet command, FileInfo file, ArchiveFormat format) { //Debug.Assert(format != ArchiveFormat.Unknown, "format != ArchiveFormat.Unknown"); _command = command; _file = file; _format = format; _archivePscxPath = PscxPathInfo.GetPscxPathInfo(_command.SessionState, file.FullName); }
internal static Guid GetClassIdFromKnownFormat(ArchiveFormat format) { Guid result; if (FormatClassMap.TryGetValue(format, out result)) { return(result); } return(Guid.Empty); }
// Archive object for creation public Archive(ArchiveFormat format, string filename) { // Set up information Name = null; Extension = null; Filename = filename; Format = format; InitalizePacker(); }
public SafIndexReader6(ArchiveFormat saf, byte[] index, byte[] names, int count) : base(saf, index, count) { m_names = names; EntrySize = 16; OffsetPos = 4; SizePos = 8; UnpackedPos = 12; DirIndexPos = 4; DirCountPos = 12; }
public LayArchive(ArcView arc, ArchiveFormat impl, ICollection <Entry> dir, BitmapSource image, IList <LayCoord> tiles) : base(arc, impl, dir) { Source = image; Tiles = tiles; LayerMap = new Dictionary <uint, LayEntry> (dir.Count); foreach (LayEntry entry in dir) { LayerMap[entry.Id] = entry; } }
public BdfArchive(ArcView arc, ArchiveFormat impl, ICollection <Entry> dir) : base(arc, impl, dir) { var base_frame = dir.First() as BdfFrame; Info = new ImageMetaData { Width = (uint)base_frame.Width, Height = (uint)base_frame.Height, BPP = 24 }; }
public override void ExportArchive(PrivateKey pk, IEnumerable <Crt> certs, ArchiveFormat fmt, Stream target, string password) { var rsaPk = pk as RsaPrivateKey; if (rsaPk == null) { throw new NotSupportedException("unsupported private key type"); } if (fmt == ArchiveFormat.PKCS12) { var bcCerts = certs.Select(x => new X509CertificateEntry(FromCertPem(x.Pem))).ToArray(); var bcPk = FromPrivatePem(rsaPk.Pem); var pfx = new Pkcs12Store(); //pfx.SetCertificateEntry(bcCerts[0].Certificate.ToString(), bcCerts[0]); //pfx.SetKeyEntry(bcCerts[0].Certificate.ToString(), pfx.SetCertificateEntry(string.Empty, bcCerts[0]); pfx.SetKeyEntry(string.Empty, new AsymmetricKeyEntry(bcPk.Private), new[] { bcCerts[0] }); for (int i = 1; i < bcCerts.Length; ++i) { //pfx.SetCertificateEntry(bcCerts[i].Certificate.SubjectDN.ToString(), pfx.SetCertificateEntry(i.ToString(), bcCerts[i]); } // It used to be pretty straight forward to export this... //pfx.Save(target, password?.ToCharArray(), new SecureRandom()); // ...unfortunately, BC won't let us export the Pkcs12 archive // without assigning a FriendlyName, so we have to export and // then re-import it, clear the FriendlyName, then return that // YUCK! using (var tmp = new MemoryStream()) { pfx.Save(tmp, null, new SecureRandom()); var c = new System.Security.Cryptography.X509Certificates.X509Certificate2(); c.Import(tmp.ToArray(), string.Empty, System.Security.Cryptography.X509Certificates.X509KeyStorageFlags.PersistKeySet | System.Security.Cryptography.X509Certificates.X509KeyStorageFlags.Exportable); // Clear the FriendlyName c.FriendlyName = null; var bytes = c.Export(System.Security.Cryptography.X509Certificates.X509ContentType.Pkcs12, password); target.Write(bytes, 0, bytes.Length); } } else { throw new NotSupportedException("unsupported archive format"); } }
/// <summary> /// Get an archive of a given repository's contents, using a specific format and reference /// </summary> /// <remarks>https://developer.github.com/v3/repos/contents/#get-archive-link</remarks> /// <param name="owner">The owner of the repository</param> /// <param name="name">The name of the repository</param> /// <param name="archiveFormat">The format of the archive. Can be either tarball or zipball</param> /// <param name="reference">A valid Git reference.</param> /// <returns>The binary contents of the archive</returns> public async Task <byte[]> GetArchive(string owner, string name, ArchiveFormat archiveFormat, string reference) { Ensure.ArgumentNotNullOrEmptyString(owner, "owner"); Ensure.ArgumentNotNullOrEmptyString(name, "name"); var endpoint = ApiUrls.RepositoryArchiveLink(owner, name, archiveFormat, reference); var response = await Connection.Get <byte[]>(endpoint, TimeSpan.FromMinutes(60)); return(response.Body); }
public ProgramPackage( Stream stream, ArchiveFormat format, byte[] sha256, Uid?dekId = null) { Stream = stream ?? throw new ArgumentNullException(nameof(stream)); Format = format; Sha256 = sha256 ?? throw new ArgumentNullException(nameof(sha256)); DekId = dekId; }
/// <summary> /// Get an archive of a given repository's contents, in a specific format /// </summary> /// <remarks>https://developer.github.com/v3/repos/contents/#get-archive-link</remarks> /// <param name="repositoryId">The Id of the repository</param> /// <param name="archiveFormat">The format of the archive. Can be either tarball or zipball</param> /// <param name="reference">A valid Git reference.</param> /// <param name="timeout"> Time span until timeout </param> public async Task <byte[]> GetArchive(int repositoryId, ArchiveFormat archiveFormat, string reference, TimeSpan timeout) { Ensure.ArgumentNotNull(reference, "reference"); Ensure.GreaterThanZero(timeout, "timeout"); var endpoint = ApiUrls.RepositoryArchiveLink(repositoryId, archiveFormat, reference); var response = await Connection.Get <byte[]>(endpoint, timeout).ConfigureAwait(false); return(response.Body); }
/// <summary> /// Get an archive of a given repository's contents, in a specific format /// </summary> /// <remarks>https://developer.github.com/v3/repos/contents/#get-archive-link</remarks> /// <param name="owner">The owner of the repository</param> /// <param name="name">The name of the repository</param> /// <param name="archiveFormat">The format of the archive. Can be either tarball or zipball</param> /// <param name="reference">A valid Git reference.</param> /// <param name="timeout"> Time span until timeout </param> /// <returns>The binary contents of the archive</returns> public async Task <byte[]> GetArchive(string owner, string name, ArchiveFormat archiveFormat, string reference, TimeSpan timeout) { Ensure.ArgumentNotNullOrEmptyString(owner, "owner"); Ensure.ArgumentNotNullOrEmptyString(name, "name"); Ensure.GreaterThanZero(timeout, "timeout"); var endpoint = ApiUrls.RepositoryArchiveLink(owner, name, archiveFormat, reference); var response = await Connection.Get <byte[]>(endpoint, timeout); return(response.Body); }
/// <summary> /// Towrzenie nowego zestawu kompresji /// </summary> /// <param name="name">Nazwa zestwu</param> /// <param name="compression">Prędkość kompresji</param> /// <param name="format">Format archiwum</param> /// <param name="method">Metoda kompresji</param> /// <param name="directory">Lokalizacja plików do kompresji</param> /// <param name="outputDirectory">Lokalizacja zapisu archiwum</param> /// <param name="filesToTake">Lista plików do kompresji.</param> public CompressionData(string name, Compression compression, ArchiveFormat format, Method method, string directory, string outputDirectory, params string[] filesToTake) { Directory = directory; Name = name; Method = method; ArchiveFormat = format; OutputDirectory = outputDirectory; Compression = compression; FormatsToTake = null; FilesToTake = filesToTake; }
/// <summary> /// Towrzenie nowego zestawu kompresji /// </summary> /// <param name="name">Nazwa zestwu</param> /// <param name="compression">Prędkość kompresji</param> /// <param name="format">Format archiwum</param> /// <param name="method">Metoda kompresji</param> /// <param name="directory">Lokalizacja plików do kompresji</param> /// <param name="outputDirectory">Lokalizacja zapisu archiwum</param> /// <param name="formatsToTake">Format plików do kompresji. Domyślnie Format.All (Wszystkie)</param> public CompressionData(string name, Compression compression, ArchiveFormat format, Method method, string directory, string outputDirectory, Format[] formatsToTake = null) { Directory = directory; Name = name; Method = method; ArchiveFormat = format; OutputDirectory = outputDirectory; Compression = compression; FilesToTake = null; FormatsToTake = (formatsToTake == null || formatsToTake.Contains(Format.All) || formatsToTake.Length == 0) ? new[] { Format.All } : formatsToTake; }
/// <summary> /// Creates a deep copy of 'mod'. /// </summary> /// <param name="mod">The object it makes a copy of.</param> public ManagedMod(ManagedMod mod) { /* * Info */ this.title = mod.title; this.ID = mod.ID; this.URL = mod.URL; this.Version = mod.Version; this.guid = mod.guid; this.GamePath = mod.GamePath; this.ManagedFolderName = mod.ManagedFolderName; /* * General */ this.Enabled = mod.Enabled; this.Deployed = mod.Deployed; this.Method = mod.Method; this.PreviousMethod = mod.PreviousMethod; /* * SeparateBA2 */ this.archiveName = mod.archiveName; this.CurrentArchiveName = mod.CurrentArchiveName; this.Compression = mod.Compression; this.CurrentCompression = mod.CurrentCompression; this.Format = mod.Format; this.CurrentFormat = mod.CurrentFormat; /* * SeparateBA2 Frozen */ this.Freeze = mod.Freeze; this.Frozen = mod.Frozen; this.FrozenCompression = mod.FrozenCompression; this.FrozenFormat = mod.FrozenFormat; /* * Loose */ this.LooseFiles = new List <string>(mod.LooseFiles); this.RootFolder = mod.RootFolder; this.CurrentRootFolder = mod.CurrentRootFolder; }
public List <Entry> ReadIndex(uint entry_size) { int count = (int)(m_index.MaxOffset / entry_size); if (!ArchiveFormat.IsSaneCount(count)) { return(null); } if (null == m_dir) { m_dir = new List <Entry> (count); } else { m_dir.Clear(); } uint idx_offset = 0; for (int i = 0; i < count; ++i) { if (idx_offset + entry_size > m_index.MaxOffset) { return(null); } int name_offset = m_index.View.ReadInt32(idx_offset); if (name_offset < 0 || name_offset >= m_names.Length) { return(null); } var name = Binary.GetCString(m_names, name_offset, m_names.Length - name_offset); var entry = FormatCatalog.Instance.Create <PackedEntry> (name); entry.Offset = m_index.View.ReadUInt32(idx_offset + 4); entry.Size = m_index.View.ReadUInt32(idx_offset + 8); if (!entry.CheckPlacement(m_arc.MaxOffset)) { return(null); } entry.IsPacked = true; if (entry_size >= 0x14) { entry.UnpackedSize = m_index.View.ReadUInt32(idx_offset + 0x10); } if (name.EndsWith(".bmp.txt", StringComparison.OrdinalIgnoreCase)) { entry.Type = "image"; } m_dir.Add(entry); idx_offset += entry_size; } return(m_dir); }
public static string ToTypeString(this ArchiveFormat ot) { switch (ot) { case ArchiveFormat.ArchiveZip: return("zip"); case ArchiveFormat.ArchiveTarGz: return("tar.gz"); default: return(""); } }
public List <Entry> ReadIndexV2() { if (!ArchiveFormat.IsSaneCount((int)m_count)) { return(null); } uint names_size = m_file.View.ReadUInt32(0x10) ^ NextKey(); uint index_size = m_count * 12; var index = m_file.View.ReadBytes(0x14, index_size); if (index.Length != index_size) { return(null); } uint filenames_base = 0x14 + index_size; var names = m_file.View.ReadBytes(filenames_base, names_size); if (names.Length != names_size) { return(null); } Decrypt(index); int index_offset = 0; var dir = new List <Entry> ((int)m_count); for (uint i = 0; i < m_count; ++i) { int filename_offset = LittleEndian.ToInt32(index, index_offset); if (filename_offset < 0 || filename_offset >= names.Length) { return(null); } var name = Binary.GetCString(names, filename_offset, names.Length - filename_offset); if (0 == name.Length) { return(null); } var entry = FormatCatalog.Instance.Create <Entry> (name); entry.Offset = LittleEndian.ToUInt32(index, index_offset + 4); entry.Size = LittleEndian.ToUInt32(index, index_offset + 8); if (!entry.CheckPlacement(m_file.MaxOffset)) { return(null); } index_offset += 12; dir.Add(entry); } return(dir); }
public override void ExportArchive(PrivateKey pk, IEnumerable <Crt> certs, ArchiveFormat fmt, Stream target, string password = "") { var rsaPk = pk as RsaPrivateKey; if (rsaPk == null) { throw new NotSupportedException("unsupported private key type"); } if (fmt == ArchiveFormat.PKCS12) { var x509Arr = certs.Select(x => { using (var bio = BIO.MemoryBuffer()) { bio.Write(x.Pem); return(new X509Certificate(bio)); } }).ToArray(); using (var key = CryptoKey.FromPrivateKey(rsaPk.Pem, null)) { var caStack = new OpenSSL.Core.Stack <X509Certificate>(); for (int i = 1; i < x509Arr.Length; ++i) { caStack.Add(x509Arr[i]); } using (var pfx = new PKCS12(password == string.Empty ? null : password, key, x509Arr[0], caStack)) { using (var bio = BIO.MemoryBuffer()) { pfx.Write(bio); var count = (int)bio.BytesPending; var array = bio.ReadBytes(count); target.Write(array.Array, 0, count); } } } foreach (var x in x509Arr) { x.Dispose(); } } else { throw new NotSupportedException("unsupported archive format"); } }
// CreateArchive creates given format of archive to the destination. public async Task CreateArchive(ArchiveFormat format, string dst) { var prefix = Utils.BasePath(this.Repo.Path.TrimSuffix(".git")) + "/"; var cmd = new Command("archive", "--prefix=" + prefix, "--format=" + format.ToTypeString(), "-o", dst, this.ID.String()); var result = await cmd.RunAsync(dir : this.Repo.Path); if (!string.IsNullOrEmpty(result.StdErr)) { throw new Exception(result.StdErr); } }
internal ArchiveEntry(IArchiveEntry archiveEntry, string archivePath, ArchiveFormat archiveFormat) { Index = (uint)archiveEntry.Index; Path = archiveEntry.FilePath; Size = (ulong)archiveEntry.Size; Name = System.IO.Path.GetFileName(archiveEntry.FilePath); CompressedSize = 0; // Not supported in SevenZipSharp (yet) ModifiedDate = archiveEntry.LastModifiedTime.GetValueOrDefault(); IsEncrypted = archiveEntry.IsEncrypted; IsFolder = archiveEntry.IsDirectory; ArchivePath = archivePath; Format = archiveFormat; CRC = archiveEntry.Crc; UnderlyingObject = archiveEntry; }
private void OpenArchive(Stream data, string fname, ArchiveFormat format) { // Let's open the archive and add it to the stack ArchiveReader archive = Archive.Open(data, format); ArchiveInfo info = new ArchiveInfo(); info.Format = format; info.Archive = archive; openedArchives.Push(info); openedArchiveNames.Add((fname == String.Empty ? "Unnamed" : fname)); Populate(info); }
internal ArchiveEntry(IArchiveEntry archiveEntry, string archivePath, ArchiveFormat archiveFormat) { Index = (uint) archiveEntry.Index; Path = archiveEntry.FilePath; Size = (ulong)archiveEntry.Size; Name = System.IO.Path.GetFileName(archiveEntry.FilePath); CompressedSize = 0; // Not supported in SevenZipSharp (yet) ModifiedDate = archiveEntry.LastModifiedTime.GetValueOrDefault (); IsEncrypted = archiveEntry.IsEncrypted; IsFolder = archiveEntry.IsDirectory; ArchivePath = archivePath; Format = archiveFormat; CRC = archiveEntry.Crc; UnderlyingObject = archiveEntry; }
bool ReadDir(string root, long base_offset) { m_input.BaseStream.Position = base_offset; if (0x5542494C != m_input.ReadUInt32()) // 'LIBU' { return(false); } m_input.ReadInt32(); int count = m_input.ReadInt32(); if (!ArchiveFormat.IsSaneCount(count)) { return(false); } if (m_dir.Capacity < m_dir.Count + count) { m_dir.Capacity = m_dir.Count + count; } long index_pos = base_offset + 0x10; for (int i = 0; i < count; ++i) { m_input.BaseStream.Position = index_pos; var name = ReadName(); uint entry_size = m_input.ReadUInt32(); long entry_offset = base_offset + m_input.ReadInt64(); index_pos = m_input.BaseStream.Position; bool has_extension = -1 != name.IndexOf('.'); name = Path.Combine(root, name); if (!has_extension && ReadDir(name, entry_offset)) { continue; } var entry = FormatCatalog.Instance.Create <Entry> (name); entry.Offset = entry_offset; entry.Size = entry_size; if (!entry.CheckPlacement(m_max_offset)) { return(false); } m_dir.Add(entry); } return(true); }
public GetArchiveLinkRequest(string accountName, string repositoryName, Revision revision, ArchiveFormat format = ArchiveFormat.Zipball) { #region Preconditions if (accountName == null) throw new ArgumentNullException(nameof(accountName)); if (repositoryName == null) throw new ArgumentNullException(nameof(repositoryName)); #endregion AccountName = accountName; RepositoryName = repositoryName; Revision = revision; Format = format; }
public PackIndexReader(PackOpener fmt, ArcView file, long index_offset) { m_fmt = fmt; m_file = file; m_pack_version = new Version(m_file.View.ReadByte(index_offset + 0xB) - '0', m_file.View.ReadByte(index_offset + 0xD) - '0'); m_count = m_file.View.ReadInt32(index_offset + 0x10); if (!ArchiveFormat.IsSaneCount(m_count)) { throw new InvalidFormatException(); } m_index_offset = m_file.View.ReadInt64(index_offset + 0x14); if (index_offset < 0 || index_offset >= m_file.MaxOffset) { throw new InvalidFormatException(); } m_index = m_file.CreateStream(m_index_offset); m_dir = new List <Entry> (m_count); }
/// <summary> /// Get an archive of a given repository's contents, in a specific format /// </summary> /// <remarks>https://developer.github.com/v3/repos/contents/#get-archive-link</remarks> /// <param name="owner">The owner of the repository</param> /// <param name="name">The name of the repository</param> /// <param name="archiveFormat">The format of the archive. Can be either tarball or zipball</param> public Task<byte[]> GetArchive(string owner, string name, ArchiveFormat archiveFormat) { Ensure.ArgumentNotNullOrEmptyString(owner, "owner"); Ensure.ArgumentNotNullOrEmptyString(name, "name"); return GetArchive(owner, name, archiveFormat, string.Empty); }
/// <summary> /// Get an archive of a given repository's contents, using a specific format and reference /// </summary> /// <remarks>https://developer.github.com/v3/repos/contents/#get-archive-link</remarks> /// <param name="owner">The owner of the repository</param> /// <param name="name">The name of the repository</param> /// <param name="archiveFormat">The format of the archive. Can be either tarball or zipball</param> /// <param name="reference">A valid Git reference.</param> /// <returns>The binary contents of the archive</returns> public async Task<byte[]> GetArchive(string owner, string name, ArchiveFormat archiveFormat, string reference) { Ensure.ArgumentNotNullOrEmptyString(owner, "owner"); Ensure.ArgumentNotNullOrEmptyString(name, "name"); var endpoint = ApiUrls.RepositoryArchiveLink(owner, name, archiveFormat, reference); var response = await Connection.Get<byte[]>(endpoint, TimeSpan.FromMinutes(60)); return response.Body; }
public IsfArchive(ArcView arc, ArchiveFormat impl, ICollection<Entry> dir, byte[] secret = null) : base(arc, impl, dir) { Secret = secret; }
/// <summary> /// Get an archive of a given repository's contents, in a specific format /// </summary> /// <remarks>https://developer.github.com/v3/repos/contents/#get-archive-link</remarks> /// <param name="owner">The owner of the repository</param> /// <param name="name">The name of the repository</param> /// <param name="archiveFormat">The format of the archive. Can be either tarball or zipball</param> /// <param name="reference">A valid Git reference.</param> /// <param name="timeout"> Time span until timeout </param> /// <returns>The binary contents of the archive</returns> public IObservable<byte[]> GetArchive(string owner, string name, ArchiveFormat archiveFormat, string reference, TimeSpan timeout) { Ensure.ArgumentNotNullOrEmptyString(owner, "owner"); Ensure.ArgumentNotNullOrEmptyString(name, "name"); Ensure.GreaterThanZero(timeout, "timeout"); return _client.Repository.Content.GetArchive(owner, name, archiveFormat, reference, timeout).ToObservable(); }
public IObservable<string> GetArchiveLink(string owner, string name, ArchiveFormat archiveFormat, string reference) { Ensure.ArgumentNotNullOrEmptyString(owner, "owner"); Ensure.ArgumentNotNullOrEmptyString(name, "name"); return _client.Repository.Content.GetArchiveLink(owner, name, archiveFormat, reference).ToObservable(); }
internal PscxSevenZipReader(PscxCmdlet command, FileInfo file, ArchiveFormat format) : base(command, file, format) { command.WriteDebug(String.Format("Created {0} reader for {1}.", format, file)); }
/// <summary> /// Returns the <see cref="Uri"/> for getting an archive of a given repository's contents, in a specific format /// </summary> /// <param name="repositoryId">The Id of the repository</param> /// <param name="archiveFormat">The format of the archive. Can be either tarball or zipball</param> /// <param name="reference">A valid Git reference.</param> /// <returns>The <see cref="Uri"/> for getting an archive of a given repository's contents, in a specific format</returns> public static Uri RepositoryArchiveLink(int repositoryId, ArchiveFormat archiveFormat, string reference) { return "repositories/{0}/{1}/{2}".FormatUri(repositoryId, archiveFormat.ToParameter(), reference); }
public DxArchive(ArcView arc, ArchiveFormat impl, ICollection<Entry> dir, byte[] key) : base(arc, impl, dir) { Key = key; }
public QlieArchive(ArcView arc, ArchiveFormat impl, ICollection<Entry> dir, uint hash, byte[] key_data) : base(arc, impl, dir) { Hash = hash; GameKeyData = key_data; }
private void OpenArchive(Stream data, string fname, ArchiveFormat format) { // Let's open the archive and add it to the stack ArchiveReader archive = Archive.Open(data, format); ArchiveInfo info = new ArchiveInfo(); info.Format = format; info.Archive = archive; openedArchives.Push(info); openedArchiveNames.Add((fname == String.Empty ? "Unnamed" : fname)); Populate(info); }
public AzArchive(ArcView arc, ArchiveFormat impl, ICollection<Entry> dir, uint syskey, uint regkey) : base(arc, impl, dir) { SysenvKey = syskey; RegularKey = regkey; }
public BdfArchive(ArcView arc, ArchiveFormat impl, ICollection<Entry> dir) : base(arc, impl, dir) { }
/// <summary> /// Set the format for the generated archive. Currently only 'zip' is supported. /// </summary> public ArchiveParams TargetFormat(ArchiveFormat targetFormat) { this.m_targetFormat = targetFormat; return this; }
/// <summary> /// Get an archive of a given repository's contents, using a specific format and reference /// </summary> /// <remarks>https://developer.github.com/v3/repos/contents/#get-archive-link</remarks> /// <param name="owner">The owner of the repository</param> /// <param name="name">The name of the repository</param> /// <param name="archiveFormat">The format of the archive. Can be either tarball or zipball</param> /// <param name="reference">A valid Git reference.</param> /// <returns>A promise, containing the binary contents of the archive</returns> public IObservable<byte[]> GetArchive(string owner, string name, ArchiveFormat archiveFormat, string reference) { return _client.Repository.Content.GetArchive(owner, name, archiveFormat, reference).ToObservable(); }
public LuciArchive(ArcView arc, ArchiveFormat impl, ICollection<Entry> dir, EncryptionScheme scheme, LpkInfo info) : base(arc, impl, dir) { Info = info; Scheme = scheme; }
/// <summary> /// Get an archive of a given repository's contents, in a specific format /// </summary> /// <remarks>https://developer.github.com/v3/repos/contents/#get-archive-link</remarks> /// <param name="repositoryId">The Id of the repository</param> /// <param name="archiveFormat">The format of the archive. Can be either tarball or zipball</param> /// <param name="reference">A valid Git reference.</param> /// <param name="timeout"> Time span until timeout </param> public async Task<byte[]> GetArchive(int repositoryId, ArchiveFormat archiveFormat, string reference, TimeSpan timeout) { Ensure.ArgumentNotNull(reference, "reference"); Ensure.GreaterThanZero(timeout, "timeout"); var endpoint = ApiUrls.RepositoryArchiveLink(repositoryId, archiveFormat, reference); var response = await Connection.Get<byte[]>(endpoint, timeout).ConfigureAwait(false); return response.Body; }
/// <summary> /// Get an archive of a given repository's contents, in a specific format /// </summary> /// <remarks>https://developer.github.com/v3/repos/contents/#get-archive-link</remarks> /// <param name="owner">The owner of the repository</param> /// <param name="name">The name of the repository</param> /// <param name="archiveFormat">The format of the archive. Can be either tarball or zipball</param> /// <param name="reference">A valid Git reference.</param> /// <param name="timeout"> Time span until timeout </param> /// <returns>The binary contents of the archive</returns> public async Task<byte[]> GetArchive(string owner, string name, ArchiveFormat archiveFormat, string reference, TimeSpan timeout) { Ensure.ArgumentNotNullOrEmptyString(owner, "owner"); Ensure.ArgumentNotNullOrEmptyString(name, "name"); Ensure.GreaterThanZero(timeout, "timeout"); var endpoint = ApiUrls.RepositoryArchiveLink(owner, name, archiveFormat, reference); var response = await Connection.Get<byte[]>(endpoint, timeout).ConfigureAwait(false); return response.Body; }
/// <summary> /// Get an archive of a given repository's contents, using a specific format and reference /// </summary> /// <remarks>https://developer.github.com/v3/repos/contents/#get-archive-link</remarks> /// <param name="repositoryId">The Id of the repository</param> /// <param name="archiveFormat">The format of the archive. Can be either tarball or zipball</param> /// <param name="reference">A valid Git reference.</param> public Task<byte[]> GetArchive(int repositoryId, ArchiveFormat archiveFormat, string reference) { Ensure.ArgumentNotNull(reference, "reference"); return GetArchive(repositoryId, archiveFormat, reference, TimeSpan.FromMinutes(60)); }
public static Uri RepositoryArchiveLink(string owner, string name, ArchiveFormat archiveFormat, string reference) { return "repos/{0}/{1}/{2}/{3}".FormatUri(owner, name, archiveFormat.ToParameter(), reference); }
/// <summary> /// Get an archive of a given repository's contents, using a specific format and reference /// </summary> /// <remarks>https://developer.github.com/v3/repos/contents/#get-archive-link</remarks> /// <param name="owner">The owner of the repository</param> /// <param name="name">The name of the repository</param> /// <param name="archiveFormat">The format of the archive. Can be either tarball or zipball</param> /// <param name="reference">A valid Git reference.</param> public Task<byte[]> GetArchive(string owner, string name, ArchiveFormat archiveFormat, string reference) { Ensure.ArgumentNotNullOrEmptyString(owner, "owner"); Ensure.ArgumentNotNullOrEmptyString(name, "name"); Ensure.ArgumentNotNull(reference, "reference"); return GetArchive(owner, name, archiveFormat, reference, TimeSpan.FromMinutes(60)); }
/// <summary> /// Get an archive of a given repository's contents, in a specific format /// </summary> /// <remarks>https://developer.github.com/v3/repos/contents/#get-archive-link</remarks> /// <param name="owner">The owner of the repository</param> /// <param name="name">The name of the repository</param> /// <param name="archiveFormat">The format of the archive. Can be either tarball or zipball</param> /// <returns>A promise, containing the binary contents of the archive</returns> public IObservable<byte[]> GetArchive(string owner, string name, ArchiveFormat archiveFormat) { return GetArchive(owner, name, archiveFormat, string.Empty); }
/// <summary> /// Get an archive of a given repository's contents, in a specific format /// </summary> /// <remarks>https://developer.github.com/v3/repos/contents/#get-archive-link</remarks> /// <param name="repositoryId">The Id of the repository</param> /// <param name="archiveFormat">The format of the archive. Can be either tarball or zipball</param> public Task<byte[]> GetArchive(int repositoryId, ArchiveFormat archiveFormat) { return GetArchive(repositoryId, archiveFormat, string.Empty); }
/// <summary> /// Get an archive of a given repository's contents, using a specific format and reference /// </summary> /// <remarks>https://developer.github.com/v3/repos/contents/#get-archive-link</remarks> /// <param name="owner">The owner of the repository</param> /// <param name="name">The name of the repository</param> /// <param name="archiveFormat">The format of the archive. Can be either tarball or zipball</param> /// <param name="reference">A valid Git reference.</param> /// <returns>A promise, containing the binary contents of the archive</returns> public IObservable<byte[]> GetArchive(string owner, string name, ArchiveFormat archiveFormat, string reference) { return GetArchive(owner, name, archiveFormat, reference, TimeSpan.FromMinutes(60)); }
public GetArchiveLinkRequest(string userName, string nameOfRepository, ArchiveFormat formatOfArchive, string @ref) : base(string.Format("/repos/{0}/{1}/{2}/{3}", userName, nameOfRepository, formatOfArchive.ToString().ToLower(), @ref)) { }
public IObservable<string> GetArchiveLink(string owner, string name, ArchiveFormat archiveFormat) { return GetArchiveLink(owner, name, archiveFormat, string.Empty); }
/// <summary> /// This method will return a 302 to a URL to download a tarball or zipball archive for a repository. /// Please make sure your HTTP framework is configured to follow redirects or you will need to use the /// Location header to make a second GET request. /// Note: For private repositories, these links are temporary and expire quickly. /// </summary> /// <remarks>https://developer.github.com/v3/repos/contents/#get-archive-link</remarks> /// <param name="owner">The owner of the repository</param> /// <param name="name">The name of the repository</param> /// <param name="archiveFormat">The format of the archive. Can be either tarball or zipball</param> /// <param name="reference">A valid Git reference.</param> /// <returns></returns> public Task<string> GetArchiveLink(string owner, string name, ArchiveFormat archiveFormat, string reference) { Ensure.ArgumentNotNullOrEmptyString(owner, "owner"); Ensure.ArgumentNotNullOrEmptyString(name, "name"); return ApiConnection.GetRedirect(ApiUrls.RepositoryArchiveLink(owner, name, archiveFormat, reference)); }