├── .github
    └── workflows
    │   └── test.yml
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── assets
    ├── 0-demo.gif
    ├── 1-demo.gif
    └── 2-demo.gif
├── cmd
    └── partdec
    │   └── partdec.go
├── docs
    ├── help_page
    └── version_page
├── download.go
├── download_test.go
├── error.go
├── fileio.go
├── flow.go
├── go.mod
├── go.sum
├── httpio.go
├── init_windows.go
├── input.go
├── third_party
    └── spf13
    │   └── pflag
    │       └── LICENSE.txt
└── ui.go


/.github/workflows/test.yml:
--------------------------------------------------------------------------------
 1 | # This workflow will build a golang project
 2 | # For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-go
 3 | 
 4 | name: Go Unit Test
 5 | 
 6 | on:
 7 |   push:
 8 |     branches: [ "master", "sandbox" ]
 9 |   pull_request:
10 |     branches: [ "master", "sandbox" ]
11 |   workflow_dispatch:
12 |     
13 | jobs:
14 | 
15 |   build:
16 |     runs-on: ubuntu-latest
17 |     steps:
18 |     - uses: actions/checkout@v4
19 | 
20 |     - name: Set up Go
21 |       uses: actions/setup-go@v4
22 |       with:
23 |         go-version: '1.24.2'
24 | 
25 |     - name: Test
26 |       run: go test -v -race -run TestNewDownload
27 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | ## Contributing
2 | Contributions are welcome from anyone interested in helping improve partdec. If you’d like to contribute:
3 | 
4 | * **Create a [GitHub pull request](https://github.com/cjijcb/partdec/pulls)**: fork the repository, make your changes, and submit a pull request.
5 | * **Create a [GitHub issue](https://github.com/cjijcb/partdec/issues)**: report bugs, suggest features, or start discussions.
6 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 |    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 |    1. Definitions.
  8 | 
  9 |       "License" shall mean the terms and conditions for use, reproduction,
 10 |       and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |       "Licensor" shall mean the copyright owner or entity authorized by
 13 |       the copyright owner that is granting the License.
 14 | 
 15 |       "Legal Entity" shall mean the union of the acting entity and all
 16 |       other entities that control, are controlled by, or are under common
 17 |       control with that entity. For the purposes of this definition,
 18 |       "control" means (i) the power, direct or indirect, to cause the
 19 |       direction or management of such entity, whether by contract or
 20 |       otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |       outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |       "You" (or "Your") shall mean an individual or Legal Entity
 24 |       exercising permissions granted by this License.
 25 | 
 26 |       "Source" form shall mean the preferred form for making modifications,
 27 |       including but not limited to software source code, documentation
 28 |       source, and configuration files.
 29 | 
 30 |       "Object" form shall mean any form resulting from mechanical
 31 |       transformation or translation of a Source form, including but
 32 |       not limited to compiled object code, generated documentation,
 33 |       and conversions to other media types.
 34 | 
 35 |       "Work" shall mean the work of authorship, whether in Source or
 36 |       Object form, made available under the License, as indicated by a
 37 |       copyright notice that is included in or attached to the work
 38 |       (an example is provided in the Appendix below).
 39 | 
 40 |       "Derivative Works" shall mean any work, whether in Source or Object
 41 |       form, that is based on (or derived from) the Work and for which the
 42 |       editorial revisions, annotations, elaborations, or other modifications
 43 |       represent, as a whole, an original work of authorship. For the purposes
 44 |       of this License, Derivative Works shall not include works that remain
 45 |       separable from, or merely link (or bind by name) to the interfaces of,
 46 |       the Work and Derivative Works thereof.
 47 | 
 48 |       "Contribution" shall mean any work of authorship, including
 49 |       the original version of the Work and any modifications or additions
 50 |       to that Work or Derivative Works thereof, that is intentionally
 51 |       submitted to Licensor for inclusion in the Work by the copyright owner
 52 |       or by an individual or Legal Entity authorized to submit on behalf of
 53 |       the copyright owner. For the purposes of this definition, "submitted"
 54 |       means any form of electronic, verbal, or written communication sent
 55 |       to the Licensor or its representatives, including but not limited to
 56 |       communication on electronic mailing lists, source code control systems,
 57 |       and issue tracking systems that are managed by, or on behalf of, the
 58 |       Licensor for the purpose of discussing and improving the Work, but
 59 |       excluding communication that is conspicuously marked or otherwise
 60 |       designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |       "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |       on behalf of whom a Contribution has been received by Licensor and
 64 |       subsequently incorporated within the Work.
 65 | 
 66 |    2. Grant of Copyright License. Subject to the terms and conditions of
 67 |       this License, each Contributor hereby grants to You a perpetual,
 68 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |       copyright license to reproduce, prepare Derivative Works of,
 70 |       publicly display, publicly perform, sublicense, and distribute the
 71 |       Work and such Derivative Works in Source or Object form.
 72 | 
 73 |    3. Grant of Patent License. Subject to the terms and conditions of
 74 |       this License, each Contributor hereby grants to You a perpetual,
 75 |       worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |       (except as stated in this section) patent license to make, have made,
 77 |       use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |       where such license applies only to those patent claims licensable
 79 |       by such Contributor that are necessarily infringed by their
 80 |       Contribution(s) alone or by combination of their Contribution(s)
 81 |       with the Work to which such Contribution(s) was submitted. If You
 82 |       institute patent litigation against any entity (including a
 83 |       cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |       or a Contribution incorporated within the Work constitutes direct
 85 |       or contributory patent infringement, then any patent licenses
 86 |       granted to You under this License for that Work shall terminate
 87 |       as of the date such litigation is filed.
 88 | 
 89 |    4. Redistribution. You may reproduce and distribute copies of the
 90 |       Work or Derivative Works thereof in any medium, with or without
 91 |       modifications, and in Source or Object form, provided that You
 92 |       meet the following conditions:
 93 | 
 94 |       (a) You must give any other recipients of the Work or
 95 |           Derivative Works a copy of this License; and
 96 | 
 97 |       (b) You must cause any modified files to carry prominent notices
 98 |           stating that You changed the files; and
 99 | 
100 |       (c) You must retain, in the Source form of any Derivative Works
101 |           that You distribute, all copyright, patent, trademark, and
102 |           attribution notices from the Source form of the Work,
103 |           excluding those notices that do not pertain to any part of
104 |           the Derivative Works; and
105 | 
106 |       (d) If the Work includes a "NOTICE" text file as part of its
107 |           distribution, then any Derivative Works that You distribute must
108 |           include a readable copy of the attribution notices contained
109 |           within such NOTICE file, excluding those notices that do not
110 |           pertain to any part of the Derivative Works, in at least one
111 |           of the following places: within a NOTICE text file distributed
112 |           as part of the Derivative Works; within the Source form or
113 |           documentation, if provided along with the Derivative Works; or,
114 |           within a display generated by the Derivative Works, if and
115 |           wherever such third-party notices normally appear. The contents
116 |           of the NOTICE file are for informational purposes only and
117 |           do not modify the License. You may add Your own attribution
118 |           notices within Derivative Works that You distribute, alongside
119 |           or as an addendum to the NOTICE text from the Work, provided
120 |           that such additional attribution notices cannot be construed
121 |           as modifying the License.
122 | 
123 |       You may add Your own copyright statement to Your modifications and
124 |       may provide additional or different license terms and conditions
125 |       for use, reproduction, or distribution of Your modifications, or
126 |       for any such Derivative Works as a whole, provided Your use,
127 |       reproduction, and distribution of the Work otherwise complies with
128 |       the conditions stated in this License.
129 | 
130 |    5. Submission of Contributions. Unless You explicitly state otherwise,
131 |       any Contribution intentionally submitted for inclusion in the Work
132 |       by You to the Licensor shall be under the terms and conditions of
133 |       this License, without any additional terms or conditions.
134 |       Notwithstanding the above, nothing herein shall supersede or modify
135 |       the terms of any separate license agreement you may have executed
136 |       with Licensor regarding such Contributions.
137 | 
138 |    6. Trademarks. This License does not grant permission to use the trade
139 |       names, trademarks, service marks, or product names of the Licensor,
140 |       except as required for reasonable and customary use in describing the
141 |       origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 |    7. Disclaimer of Warranty. Unless required by applicable law or
144 |       agreed to in writing, Licensor provides the Work (and each
145 |       Contributor provides its Contributions) on an "AS IS" BASIS,
146 |       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |       implied, including, without limitation, any warranties or conditions
148 |       of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |       PARTICULAR PURPOSE. You are solely responsible for determining the
150 |       appropriateness of using or redistributing the Work and assume any
151 |       risks associated with Your exercise of permissions under this License.
152 | 
153 |    8. Limitation of Liability. In no event and under no legal theory,
154 |       whether in tort (including negligence), contract, or otherwise,
155 |       unless required by applicable law (such as deliberate and grossly
156 |       negligent acts) or agreed to in writing, shall any Contributor be
157 |       liable to You for damages, including any direct, indirect, special,
158 |       incidental, or consequential damages of any character arising as a
159 |       result of this License or out of the use or inability to use the
160 |       Work (including but not limited to damages for loss of goodwill,
161 |       work stoppage, computer failure or malfunction, or any and all
162 |       other commercial damages or losses), even if such Contributor
163 |       has been advised of the possibility of such damages.
164 | 
165 |    9. Accepting Warranty or Additional Liability. While redistributing
166 |       the Work or Derivative Works thereof, You may choose to offer,
167 |       and charge a fee for, acceptance of support, warranty, indemnity,
168 |       or other liability obligations and/or rights consistent with this
169 |       License. However, in accepting such obligations, You may act only
170 |       on Your own behalf and on Your sole responsibility, not on behalf
171 |       of any other Contributor, and only if You agree to indemnify,
172 |       defend, and hold each Contributor harmless for any liability
173 |       incurred by, or claims asserted against, such Contributor by reason
174 |       of your accepting any such warranty or additional liability.
175 | 
176 |    END OF TERMS AND CONDITIONS
177 | 
178 |    APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "[]"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 |    Copyright 2024 Carlo Jay I. Jacaba
190 | 
191 |    Licensed under the Apache License, Version 2.0 (the "License");
192 |    you may not use this file except in compliance with the License.
193 |    You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 |    Unless required by applicable law or agreed to in writing, software
198 |    distributed under the License is distributed on an "AS IS" BASIS,
199 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 |    See the License for the specific language governing permissions and
201 |    limitations under the License.
202 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # partdec
 2 | [![Go Report Card](https://goreportcard.com/badge/github.com/cjijcb/partdec)](https://goreportcard.com/report/github.com/cjijcb/partdec)
 3 | [![Codacy Badge](https://app.codacy.com/project/badge/Grade/af4b1b130f194d6caa0edeb4cce4d342)](https://app.codacy.com/gh/cjijcb/partdec/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
 4 | 
 5 | **partdec** is a command-line utility for multipart downloading and file splitting.
 6 | It can download a file in parts simultaneously from a remote or local source and distribute parts of the file to multiple destination paths.
 7 | 
 8 | partdec allows a separate connection per file part and the ability to resume interrupted file transfers.
 9 | It supports HTTP and HTTPS protocols.
10 | 
11 | 
12 | ## Demo
13 | ![0-demo](https://github.com/cjijcb/partdec/blob/master/assets/0-demo.gif) 
14 | 
15 | <details>
16 | <summary><strong>See more ...</strong></summary>
17 | <img src="https://github.com/cjijcb/partdec/blob/master/assets/1-demo.gif">
18 | <img src="https://github.com/cjijcb/partdec/blob/master/assets/2-demo.gif"> 
19 | </details>
20 | 
21 | ## Use Cases
22 | 
23 | - **Download Acceleration** <br>
24 |   Multipart or segmented download is a commonly used technique to accelerate download
25 |   speeds by retrieving multiple parts of a file simultaneously.
26 | 
27 | - **Data Partitioning and Distribution** <br>
28 |   In cases when data has to come from one endpoint and then be split into parts and
29 |   distributed across multiple nodes or servers.
30 | 
31 | - **Large File Management** <br>
32 |   Transferring a file in parts solves the problem of file size restrictions imposed by
33 |   file systems. For instance, transferring a file larger than 4GB to a FAT32 system.
34 | 
35 | ## Installation
36 | > [!NOTE]
37 | > For installation, `go` version 1.22.8 or later is required.
38 | 
39 | Install it with `go`:
40 | ```bash
41 | go install github.com/cjijcb/partdec/cmd/partdec@latest
42 | ```
43 | 
44 | Or, to build the binary, download the latest source code archive from the [releases](https://github.com/cjijcb/partdec/releases) page,
45 | extract it, then run:
46 | ```bash
47 | cd partdec/cmd/partdec/
48 | go build -o <BINPATH> partdec.go  # Replace <BINPATH> with the path where the binary file should go
49 | ```
50 | ## Usage Information
51 | 
52 | Basic Options:
53 | ```
54 |   -p <N>     Split the file into N parts.
55 |   -s <SIZE>  Split the file into parts of SIZE.
56 |   -b <PATH>  Set the base path for output files and also set their filename.
57 |   -d <PATH>  Set the destination directory for output files. PATH can be comma-separated directories.
58 | ```
59 | See [Full Usage Information](https://github.com/cjijcb/partdec/wiki/Command%E2%80%90Line-Usage-Information).
60 | 
61 | ## Merging Files
62 | You can use `cat`, a standard Unix utility, to merge files. Other similar applications can work as well.
63 | To merge files using `cat`, the paths must be passed in ascending order based on the numeric suffix of the files.
64 | You can also use a wildcard (`*`) to represent these numeric suffixes. As follows:
65 | 
66 | Sypnosis:
67 | ```
68 | cat [PATH]<FILENAME>_* ... > [PATH]<NEWFILENAME>
69 | ```
70 | Examples:
71 | ```bash
72 | cat archive.zip_* > my_archive.zip
73 | ```
74 | ```bash
75 | cat /tmp/archive.zip_* > ~/Downloads/my_archive.zip
76 | ```
77 | ```bash
78 | cat /tmp/archive.zip_* /var/archive.zip_* > ~/Downloads/my_archive.zip
79 | ```
80 | 
81 | ## Development
82 | It is still in early development, and a lot can still change. Any contributions are welcome.
83 | There are also plans to support other protocols such as FTP(S) and SFTP.
84 | 
85 | ## License
86 | Copyright (C) 2024 Carlo Jay I. Jacaba
87 | 
88 | partdec is licensed under the Apache License, Version 2.0.
89 | 


--------------------------------------------------------------------------------
/assets/0-demo.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cjijcb/partdec/b4c5f140444b1b39e5d1f8129b2ffebfd6ef3e04/assets/0-demo.gif


--------------------------------------------------------------------------------
/assets/1-demo.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cjijcb/partdec/b4c5f140444b1b39e5d1f8129b2ffebfd6ef3e04/assets/1-demo.gif


--------------------------------------------------------------------------------
/assets/2-demo.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cjijcb/partdec/b4c5f140444b1b39e5d1f8129b2ffebfd6ef3e04/assets/2-demo.gif


--------------------------------------------------------------------------------
/cmd/partdec/partdec.go:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright 2024 Carlo Jay I. Jacaba
 3 | 
 4 | Licensed under the Apache License, Version 2.0 (the "License");
 5 | you may not use this file except in compliance with the License.
 6 | You may obtain a copy of the License at
 7 | 
 8 |     http://www.apache.org/licenses/LICENSE-2.0
 9 | 
10 | Unless required by applicable law or agreed to in writing, software
11 | distributed under the License is distributed on an "AS IS" BASIS,
12 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | See the License for the specific language governing permissions and
14 | limitations under the License.
15 | */
16 | 
17 | package main
18 | 
19 | import (
20 | 	"fmt"
21 | 	"github.com/cjijcb/partdec"
22 | 	"os"
23 | )
24 | 
25 | func main() {
26 | 
27 | 	//runtime.GOMAXPROCS(runtime.NumCPU()) //default behavior since Go 1.5
28 | 
29 | 	var d *partdec.Download
30 | 
31 | 	opt, err := partdec.NewDLOptions()
32 | 	if err != nil {
33 | 		os.Exit(1)
34 | 	}
35 | 
36 | 	d, err = partdec.NewDownload(opt)
37 | 	if err != nil {
38 | 		fmt.Fprintf(os.Stderr, "%s\n", err)
39 | 		os.Exit(1)
40 | 	}
41 | 
42 | 	err = d.Start()
43 | 	if err != nil {
44 | 		fmt.Fprintf(os.Stderr, "%s\n", err)
45 | 		os.Exit(1)
46 | 	}
47 | 
48 | }
49 | 


--------------------------------------------------------------------------------
/docs/help_page:
--------------------------------------------------------------------------------
 1 | Download a file in parts simultaneously from a remote or local source.
 2 | 
 3 | Usage: partdec [OPTIONS]... <URI|LOCAL PATH>
 4 | 
 5 | Options:
 6 |   -p, --part <N>
 7 |           Split the file into N parts. It defaults to 1, if N is zero or
 8 |           less. If -s/--size is used, this option is ignored.
 9 | 
10 |   -s, --size <SIZE>
11 |           Split the file into parts of SIZE. SIZE is in byte size and can
12 |           include the following binary prefixes:
13 |           SI: KB, MB, GB, TB (case-insensitive)
14 |           IEC: KiB, MiB, GiB, TiB, or K, M, G, T (case-insensitive)
15 | 
16 |   -b, --base <PATH>
17 |           Set the base path for output files and also set their filename.
18 |           For multiple output files, an _N suffix is added, where N is an
19 |           incrementing number starting from 1.
20 | 
21 |   -d, --dir <PATH>[,...]  
22 |           Set the destination directory for output files. Can be repeated 
23 |           and accepts comma-separated paths to specify multiple directories.
24 |           Base path is appended to each directory. 
25 | 
26 |   -z, --reset[=INDEX,...]
27 |           Reset files to [new] state. Comma-separated INDEX values can be
28 |           provided to reset specific states. INDEX values are 1, 2, and 3
29 |           for [resume], [completed], and [broken], respectively. 
30 |           (e.g., -z or -z=1,3)
31 |   
32 |   -r, --retry <N>
33 |           Set retry attempts to recover from failures during downloads.
34 |           Default is 5; set to 0 to disable. The delay between retries starts
35 |           at 1s and increases exponentially up to 32s.
36 | 
37 |   -t, --timeout <TIME>
38 |           Set the HTTP request timeout. TIME is a number followed by a
39 |           suffix: ms, s, m, or h to represent milliseconds, seconds, minutes,
40 |           or hours, respectively (e.g., -t 1h2m3s). The default is 0, meaning
41 |           no timeout.
42 | 
43 |   -H, --header <HEADER_NAME:VALUE>
44 |           Set or add an HTTP header. Can be repeated to specify multiple
45 |           headers. The Range header is ignored in multipart HTTP(S) downloads.
46 |           HEADER_NAME is case-insensitive.
47 | 
48 |   -x, --no-connection-reuse
49 |           Disable the HTTP Keep-Alive or connection reuse. This ensures a
50 |           separate connection per file part in multipart HTTP(S) downloads.
51 | 
52 |   -f, --force
53 |           Override the soft limit (128) on the total number of output files.
54 |           This option also disables output to stdout.
55 | 
56 |   -q, --quiet
57 |           Disable output to stdout.
58 | 
59 |   -V, --version
60 |           Display version information.
61 | 
62 | Output File States:
63 |     File states are based on the initial size of files and may change during
64 |     or after the download. States can also be affected by I/O operation errors
65 |     and the file scope, which determines the maximum size a file can reach.
66 | 
67 |     [new]       File with zero initial size.  
68 |     [resume]    File with non-zero initial size and within scope.  
69 |     [completed] File that has reached its maximum size.  
70 |     [broken]    File exceeding maximum size or with I/O errors.  
71 |     [unknown]   File with an indeterminate scope.
72 | 
73 |     A file with the [unknown] state is always truncated to zero size on every
74 |     run with the same arguments. This state occurs when a remote server does
75 |     not support multipart or segmented downloads.
76 | 


--------------------------------------------------------------------------------
/docs/version_page:
--------------------------------------------------------------------------------
1 | partdec version 0.4.2
2 | Copyright (C) 2024 Carlo Jay I. Jacaba
3 | 
4 | Report bugs to https://github.com/cjijcb/partdec/issues
5 | 


--------------------------------------------------------------------------------
/download.go:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright 2024 Carlo Jay I. Jacaba
  3 | 
  4 | Licensed under the Apache License, Version 2.0 (the "License");
  5 | you may not use this file except in compliance with the License.
  6 | You may obtain a copy of the License at
  7 | 
  8 | 	http://www.apache.org/licenses/LICENSE-2.0
  9 | 
 10 | Unless required by applicable law or agreed to in writing, software
 11 | distributed under the License is distributed on an "AS IS" BASIS,
 12 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 | See the License for the specific language governing permissions and
 14 | limitations under the License.
 15 | */
 16 | 
 17 | package partdec
 18 | 
 19 | import (
 20 | 	"context"
 21 | 	"fmt"
 22 | 	"io"
 23 | 	"net/http"
 24 | 	"os"
 25 | 	"os/signal"
 26 | 	"time"
 27 | )
 28 | 
 29 | type (
 30 | 	// Interface with methods for casting a range of bytes and managing the
 31 | 	// lifecycle of a data stream.
 32 | 	DataCaster interface {
 33 | 		DataCast(ByteRange) (io.ReadCloser, error)
 34 | 		Close() error
 35 | 		IsOpen() bool
 36 | 	}
 37 | 
 38 | 	IOMod struct {
 39 | 		Retry       int
 40 | 		Timeout     time.Duration
 41 | 		UserHeader  http.Header
 42 | 		NoConnReuse bool
 43 | 	}
 44 | 
 45 | 	DLType uint8
 46 | 
 47 | 	DLOptions struct {
 48 | 		URI       string
 49 | 		BasePath  string
 50 | 		DstDirs   []string
 51 | 		PartCount int
 52 | 		PartSize  int64
 53 | 		ReDL      FileResets
 54 | 		UI        func(*Download)
 55 | 		Force     bool
 56 | 		Mod       *IOMod
 57 | 	}
 58 | 
 59 | 	// Manages the entire download process.
 60 | 	Download struct {
 61 | 		Files     FileIOs
 62 | 		Sources   []DataCaster
 63 | 		URI       string
 64 | 		DataSize  int64
 65 | 		Type      DLType
 66 | 		UI        func(*Download)
 67 | 		Resumable bool
 68 | 		Mod       *IOMod
 69 | 		Flow      *FlowControl
 70 | 		Stop      context.CancelFunc
 71 | 		Ctx       context.Context
 72 | 	}
 73 | 
 74 | 	// Represents an individual file transfer endpoint for downloading.
 75 | 	endpoint struct {
 76 | 		c   context.Context
 77 | 		dc  DataCaster
 78 | 		fio *FileIO
 79 | 		r   io.ReadCloser
 80 | 		w   io.WriteCloser
 81 | 	}
 82 | )
 83 | 
 84 | const (
 85 | 	File DLType = iota
 86 | 	HTTP
 87 | 
 88 | 	PartSoftLimit      = 128
 89 | 	MaxConcurrentFetch = 32
 90 | )
 91 | 
 92 | // Initiates the download process by setting up context handling, UI updates,
 93 | // and concurrent fetching of all file parts.
 94 | func (d *Download) Start() (err error) {
 95 | 
 96 | 	d.Ctx, d.Stop = signal.NotifyContext(context.Background(), os.Interrupt)
 97 | 	defer d.Stop()
 98 | 
 99 | 	if d.UI != nil {
100 | 		d.Flow.WG.Add(1)
101 | 		go d.UI(d)
102 | 	}
103 | 
104 | 	partCount := len(d.Files)
105 | 	errCh := make(chan error, partCount)
106 | 
107 | 	d.Flow.WG.Add(1)
108 | 	go d.fetchAll(errCh)
109 | 
110 | 	err = catchErr(errCh, partCount)
111 | 	d.Stop()
112 | 
113 | 	d.Flow.WG.Wait()
114 | 	return err
115 | 
116 | }
117 | 
118 | // Manages the concurrent fetching of all file parts.
119 | func (d *Download) fetchAll(errCh chan error) {
120 | 
121 | 	defer d.Flow.WG.Done()
122 | 
123 | 	gendc := d.DataCasterGenerator()
124 | 
125 | 	for _, fio := range d.Files {
126 | 		dc, err := gendc()
127 | 
128 | 		if err != nil {
129 | 			errCh <- JoinErr(err, ErrAbort)
130 | 			return
131 | 		}
132 | 
133 | 		if fio.State == Completed || fio.State == Broken {
134 | 			dc.Close()
135 | 			fio.Close()
136 | 			errCh <- nil
137 | 			continue
138 | 		}
139 | 
140 | 		d.Flow.Acquire()
141 | 		d.Flow.WG.Add(1)
142 | 		go d.fetch(
143 | 			&endpoint{c: d.Ctx, dc: dc, fio: fio},
144 | 			errCh,
145 | 		)
146 | 	}
147 | 
148 | }
149 | 
150 | // Handles the transfer of a single file part.
151 | func (d *Download) fetch(e *endpoint, errCh chan<- error) {
152 | 
153 | 	defer d.Flow.WG.Done()
154 | 	defer d.Flow.Release()
155 | 	defer e.dc.Close()
156 | 
157 | 	if err := e.fio.Open(); err != nil {
158 | 		e.fio.PushState(Broken)
159 | 		errCh <- err
160 | 		return
161 | 	}
162 | 	defer e.fio.Close()
163 | 
164 | 	if _, err := e.fio.Seek(0, io.SeekEnd); err != nil {
165 | 		e.fio.PushState(Broken)
166 | 		errCh <- err
167 | 		return
168 | 	}
169 | 
170 | 	err := e.copyWithRetry(d.Mod.Retry)
171 | 	if err != nil {
172 | 		if !IsErr(err, context.Canceled) {
173 | 			e.fio.PushState(Broken)
174 | 		}
175 | 		errCh <- err
176 | 		return
177 | 	}
178 | 
179 | 	e.fio.PushState(Completed)
180 | 	errCh <- nil
181 | 
182 | }
183 | 
184 | // Initializes the file parts for download by setting their byte ranges
185 | // and determining their initial state based on resumability
186 | func (d *Download) InitFiles(partSize int64, fr FileResets) (err error) {
187 | 
188 | 	if err := d.Files.SetByteRange(d.DataSize, partSize); err != nil {
189 | 		return err
190 | 	}
191 | 
192 | 	switch {
193 | 	case !d.Resumable:
194 | 		for _, fio := range d.Files {
195 | 			fio.State = Unknown
196 | 			fio.Scope.Indeterminate = true
197 | 		}
198 | 	default:
199 | 		if err = d.Files.SetInitialState(); err != nil {
200 | 			return err
201 | 		}
202 | 	}
203 | 
204 | 	if err = d.Files.RenewByState(fr); err != nil {
205 | 		return err
206 | 	}
207 | 
208 | 	return nil
209 | 
210 | }
211 | 
212 | // Creates a new Download instance based on the provided DLOptions.
213 | // It determines the download type (file or HTTP), initializes file I/O handlers,
214 | // and sets up download configurations.
215 | func NewDownload(opt *DLOptions) (d *Download, err error) {
216 | 
217 | 	switch {
218 | 	case IsFile(opt.URI):
219 | 		d, err = newFileDownload(opt)
220 | 	case IsURL(opt.URI):
221 | 		d, err = newHTTPDownload(opt)
222 | 	default:
223 | 		return nil, NewErr("%s: %s", ErrFileURL, opt.URI)
224 | 	}
225 | 
226 | 	if err != nil {
227 | 		return nil, err
228 | 	}
229 | 
230 | 	fios, err := BuildFileIOs(opt.PartCount, opt.BasePath, opt.DstDirs)
231 | 	if err != nil {
232 | 		return nil, err
233 | 	}
234 | 
235 | 	d.Files = fios
236 | 
237 | 	if err = d.InitFiles(opt.PartSize, opt.ReDL); err != nil {
238 | 		return nil, err
239 | 	}
240 | 
241 | 	d.Sources = make([]DataCaster, 2*MaxConcurrentFetch) //ring buffer
242 | 	d.URI = opt.URI
243 | 	d.UI = opt.UI
244 | 	d.Flow = NewFlowControl(MaxConcurrentFetch)
245 | 	d.Mod = opt.Mod
246 | 
247 | 	return d, nil
248 | 
249 | }
250 | 
251 | // Initializes an HTTP-based download, determining its resumability,
252 | // part count, and other settings based on HTTP headers.
253 | func newHTTPDownload(opt *DLOptions) (*Download, error) {
254 | 
255 | 	if md := opt.Mod; md != nil {
256 | 		for k := range md.UserHeader {
257 | 			SharedHeader.Set(k, md.UserHeader.Get(k))
258 | 		}
259 | 		SharedTransport.CloseIdleConnections()
260 | 		SharedTransport.DisableKeepAlives = md.NoConnReuse
261 | 		SharedTransport.ResponseHeaderTimeout = md.Timeout
262 | 	}
263 | 
264 | 	var cl int64 = UnknownSize
265 | 	resumable := true
266 | 
267 | 	hdr, err := getRespInfo(&opt.URI, &cl)
268 | 	if err != nil {
269 | 		return nil, err
270 | 	}
271 | 
272 | 	if hdr.Get("Accept-Ranges") != "bytes" || cl < 0 {
273 | 		resumable = false
274 | 	}
275 | 
276 | 	if !resumable && (opt.PartCount > 1 || opt.PartSize > 0) {
277 | 		fmt.Fprintf(Stderr, "%s\n", ErrMultPart)
278 | 		opt.PartCount = 1
279 | 	}
280 | 
281 | 	if err := opt.AlignPartCountSize(cl); err != nil {
282 | 		return nil, err
283 | 	}
284 | 
285 | 	opt.ParseBasePath(hdr)
286 | 
287 | 	return &Download{
288 | 		DataSize:  cl,
289 | 		Type:      HTTP,
290 | 		Resumable: resumable,
291 | 	}, nil
292 | 
293 | }
294 | 
295 | // Initializes a local file download by determining the file size
296 | // and setting its part count and size.
297 | func newFileDownload(opt *DLOptions) (*Download, error) {
298 | 
299 | 	info, err := os.Stat(opt.URI)
300 | 	if err != nil {
301 | 		return nil, err
302 | 	}
303 | 	fs := info.Size()
304 | 
305 | 	if err := opt.AlignPartCountSize(fs); err != nil {
306 | 		return nil, err
307 | 	}
308 | 
309 | 	opt.ParseBasePath(nil)
310 | 
311 | 	return &Download{
312 | 		DataSize:  fs,
313 | 		Type:      File,
314 | 		Resumable: true,
315 | 	}, nil
316 | 
317 | }
318 | 
319 | // Generates a file name based on headers, URL, or file path.
320 | func NewFileName(uri string, hdr http.Header) string {
321 | 
322 | 	if fileName := newFileNameFromHeader(hdr); fileName != "" {
323 | 		return fileName
324 | 	}
325 | 
326 | 	if fileName := newFileNameFromURL(uri); fileName != "" {
327 | 		return fileName
328 | 	}
329 | 
330 | 	if fileName := newFileNameFromPath(uri); fileName != "" {
331 | 		return fileName
332 | 	}
333 | 
334 | 	return "unknown.partdec"
335 | 
336 | }
337 | 
338 | // Adjusts the part count and size to fit the given data size.
339 | func (opt *DLOptions) AlignPartCountSize(dataSize int64) error {
340 | 
341 | 	if dataSize < 1 {
342 | 		opt.PartCount = 1
343 | 		opt.PartSize = UnknownSize
344 | 		return nil
345 | 	}
346 | 
347 | 	switch {
348 | 	case opt.PartSize < 1:
349 | 		opt.PartSize = UnknownSize
350 | 	default:
351 | 		opt.PartCount = 1 + int((dataSize-1)/opt.PartSize) //ceiling division
352 | 	}
353 | 
354 | 	if opt.PartCount < 1 {
355 | 		opt.PartCount = 1
356 | 	}
357 | 
358 | 	if opt.PartCount > int(dataSize) || opt.PartSize > dataSize {
359 | 		return NewErr("%s: %d", ErrPartExceed, dataSize)
360 | 	}
361 | 
362 | 	if opt.PartCount > PartSoftLimit && !opt.Force {
363 | 		return NewErr("%s of %d: %d", ErrPartLimit, PartSoftLimit, opt.PartCount)
364 | 	}
365 | 
366 | 	return nil
367 | 
368 | }
369 | 
370 | // Sets the base path for storing the file, appending the file name
371 | // if the base path ends with a separator.
372 | func (opt *DLOptions) ParseBasePath(hdr http.Header) {
373 | 
374 | 	switch {
375 | 	case opt.BasePath == "":
376 | 		opt.BasePath = NewFileName(opt.URI, hdr)
377 | 	case IsEndSeparator(opt.BasePath):
378 | 		opt.BasePath += NewFileName(opt.URI, hdr)
379 | 	}
380 | 
381 | }
382 | 
383 | // Creates a function that generates DataCasters for fetching data.
384 | // It uses circular indexing to reuse existing DataCasters.
385 | func (d *Download) DataCasterGenerator() func() (DataCaster, error) {
386 | 
387 | 	var (
388 | 		gendc   func(string) (DataCaster, error)
389 | 		dcs     = d.Sources
390 | 		retries = len(dcs) + 1
391 | 		x       = 0
392 | 	)
393 | 	switch d.Type {
394 | 	case File:
395 | 		gendc = NewFileDataCaster
396 | 	case HTTP:
397 | 		gendc = NewHTTPDataCaster
398 | 	default:
399 | 		gendc = func(string) (DataCaster, error) {
400 | 			return nil, ErrDLType
401 | 		}
402 | 	}
403 | 
404 | 	return func() (dc DataCaster, err error) {
405 | 		if dc, err = gendc(d.URI); err != nil {
406 | 			return nil, err
407 | 		}
408 | 		for range retries {
409 | 			x = (x + 1) % len(dcs) //circular indexing
410 | 			if dcs[x] == nil || !dcs[x].IsOpen() {
411 | 				dcs[x] = dc
412 | 				return dcs[x], nil
413 | 			}
414 | 		}
415 | 		return nil, ErrExhaust
416 | 	}
417 | 
418 | }
419 | 
420 | // Attempts to copy data from the source to the destination with retries.
421 | // It implements exponential backoff for retry delays.
422 | func (e *endpoint) copyWithRetry(retries int) (err error) {
423 | 
424 | 	go func() {
425 | 		<-e.c.Done()
426 | 		e.fio.Close()
427 | 		if e.r != nil {
428 | 			e.r.Close()
429 | 		}
430 | 	}()
431 | 
432 | 	delay := time.Duration(0)
433 | 	t := 0
434 | 	for {
435 | 		select {
436 | 		case <-time.After(delay):
437 | 
438 | 			if e.r, err = e.dc.DataCast(e.fio.Scope); err == nil {
439 | 				if _, err = io.Copy(e.fio, e.r); err == nil {
440 | 					return nil
441 | 				}
442 | 			}
443 | 
444 | 			if t++; t >= retries {
445 | 				if e.c.Err() != nil {
446 | 					return e.c.Err()
447 | 				}
448 | 				return err
449 | 			}
450 | 
451 | 			if err = e.fio.SetOffset(); err != nil {
452 | 				return err
453 | 			}
454 | 
455 | 			delay = time.Second * 1 << min(t-1, 5) //32s max delay
456 | 
457 | 		case <-e.c.Done():
458 | 			return e.c.Err()
459 | 		}
460 | 
461 | 	}
462 | 
463 | }
464 | 


--------------------------------------------------------------------------------
/download_test.go:
--------------------------------------------------------------------------------
  1 | package partdec
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"os"
  6 | 	"testing"
  7 | )
  8 | 
  9 | var (
 10 | 	opt = DLOptions{
 11 | 		URI:       "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf",
 12 | 		BasePath:  "example.html",
 13 | 		DstDirs:   []string{"test/dira", "test/dirb"},
 14 | 		PartCount: 0,
 15 | 		PartSize:  0,
 16 | 		ReDL:      map[FileState]bool{Completed: true, Resume: true, Broken: true},
 17 | 		UI:        nil,
 18 | 		Force:     false,
 19 | 		Mod: &IOMod{
 20 | 			Timeout:     0,
 21 | 			UserHeader:  nil,
 22 | 			NoConnReuse: false,
 23 | 		},
 24 | 	}
 25 | )
 26 | 
 27 | func TestNewDownload(t *testing.T) {
 28 | 
 29 | 	var d *Download
 30 | 	var err error
 31 | 
 32 | 	os.MkdirAll("test/dira", 0750)
 33 | 	os.MkdirAll("test/dirb", 0750)
 34 | 	defer os.RemoveAll("test/")
 35 | 
 36 | 	newOpt := opt
 37 | 	if d, err = NewDownload(&newOpt); err != nil {
 38 | 		t.Errorf("unexpected error: %s\n", err)
 39 | 	}
 40 | 	dataSize := d.DataSize
 41 | 
 42 | 	newOpt = opt
 43 | 	newOpt.PartSize = (dataSize / 10)
 44 | 	if d, err = NewDownload(&newOpt); err != nil {
 45 | 		t.Errorf("unexpected error: %s\n", err)
 46 | 	}
 47 | 
 48 | 	for i := range newOpt.PartCount {
 49 | 		switch {
 50 | 		case i <= 5:
 51 | 			path := "test/dira/" + "example.html_" + fmt.Sprintf("%02d", i+1)
 52 | 			if !IsFile(path) {
 53 | 				t.Errorf("file not found: %s\n", path)
 54 | 			}
 55 | 		case i > 5 && i < 10:
 56 | 			path := "test/dirb/" + "example.html_" + fmt.Sprintf("%02d", i+1)
 57 | 			if !IsFile(path) {
 58 | 				t.Errorf("file not found: %s\n", path)
 59 | 			}
 60 | 		}
 61 | 	}
 62 | 
 63 | 	for i := range 6 {
 64 | 		newOpt := opt
 65 | 
 66 | 		switch i {
 67 | 		case 0:
 68 | 			newOpt.PartCount = -1
 69 | 			if _, err := NewDownload(&newOpt); err != nil {
 70 | 				t.Errorf("unexpected error: %s\n", err)
 71 | 			}
 72 | 			fallthrough
 73 | 		case 1:
 74 | 			newOpt.PartSize = -1
 75 | 			if _, err := NewDownload(&newOpt); err != nil {
 76 | 				t.Errorf("unexpected error: %s\n", err)
 77 | 			}
 78 | 
 79 | 		case 2:
 80 | 			newOpt.PartCount = (PartSoftLimit + 1)
 81 | 			newOpt.Force = true
 82 | 			if _, err := NewDownload(&newOpt); err != nil {
 83 | 				t.Errorf("unexpected error: %s\n", err)
 84 | 			}
 85 | 		case 3:
 86 | 			newOpt.PartCount = (PartSoftLimit + 1)
 87 | 			if _, err := NewDownload(&newOpt); err == nil {
 88 | 				t.Errorf("error is expected")
 89 | 			}
 90 | 		case 4:
 91 | 			newOpt.PartCount = (int(dataSize) + 1)
 92 | 			newOpt.Force = true
 93 | 			if _, err := NewDownload(&newOpt); err == nil {
 94 | 				t.Errorf("error is expected")
 95 | 			}
 96 | 		case 5:
 97 | 			newOpt.PartSize = (dataSize + 1)
 98 | 			if _, err := NewDownload(&newOpt); err == nil {
 99 | 				t.Errorf("error is expected")
100 | 			}
101 | 		}
102 | 
103 | 	}
104 | 
105 | }
106 | 


--------------------------------------------------------------------------------
/error.go:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright 2024 Carlo Jay I. Jacaba
 3 | 
 4 | Licensed under the Apache License, Version 2.0 (the "License");
 5 | you may not use this file except in compliance with the License.
 6 | You may obtain a copy of the License at
 7 | 
 8 |     http://www.apache.org/licenses/LICENSE-2.0
 9 | 
10 | Unless required by applicable law or agreed to in writing, software
11 | distributed under the License is distributed on an "AS IS" BASIS,
12 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | See the License for the specific language governing permissions and
14 | limitations under the License.
15 | */
16 | 
17 | package partdec
18 | 
19 | import (
20 | 	"context"
21 | 	"errors"
22 | 	"fmt"
23 | 	"os"
24 | )
25 | 
26 | var (
27 | 	JoinErr = errors.Join
28 | 	IsErr   = errors.Is
29 | 	NewErr  = fmt.Errorf
30 | 
31 | 	Stderr = os.Stderr
32 | 
33 | 	ErrCancel     = NewErr("canceled")
34 | 	ErrAbort      = NewErr("aborted")
35 | 	ErrPartExceed = NewErr("part total count or size exceeds the source file size")
36 | 	ErrFileURL    = NewErr("inaccessible file or invalid URI")
37 | 	ErrDLType     = NewErr("unknown download type")
38 | 	ErrExhaust    = NewErr("resource exhausted")
39 | 	ErrArgs       = NewErr("invalid argument")
40 | 	ErrParse      = NewErr("parse error")
41 | 	ErrPartLimit  = NewErr("exceeds output file count limit")
42 | 	ErrMultPart   = NewErr("server does not support multipart or segmented downloads")
43 | 	ErrRedir      = NewErr("redirected")
44 | 	ErrVer        = NewErr("version requested")
45 | )
46 | 
47 | func catchErr(errCh chan error, maxErrCount int) (err error) {
48 | 
49 | 	errCount := 0
50 | 	for catched := range errCh {
51 | 		if catched != nil {
52 | 
53 | 			if IsErr(catched, context.Canceled) {
54 | 				err = JoinErr(err, ErrCancel)
55 | 				break
56 | 			}
57 | 
58 | 			if IsErr(catched, ErrAbort) {
59 | 				err = JoinErr(err, ErrAbort)
60 | 				break
61 | 			}
62 | 
63 | 			err = JoinErr(err, catched)
64 | 		}
65 | 		if errCount++; errCount >= maxErrCount {
66 | 			break
67 | 		}
68 | 	}
69 | 
70 | 	return err
71 | 
72 | }
73 | 


--------------------------------------------------------------------------------
/fileio.go:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright 2024 Carlo Jay I. Jacaba
  3 | 
  4 | Licensed under the Apache License, Version 2.0 (the "License");
  5 | you may not use this file except in compliance with the License.
  6 | You may obtain a copy of the License at
  7 | 
  8 |     http://www.apache.org/licenses/LICENSE-2.0
  9 | 
 10 | Unless required by applicable law or agreed to in writing, software
 11 | distributed under the License is distributed on an "AS IS" BASIS,
 12 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 | See the License for the specific language governing permissions and
 14 | limitations under the License.
 15 | */
 16 | 
 17 | package partdec
 18 | 
 19 | import (
 20 | 	"fmt"
 21 | 	"io"
 22 | 	"os"
 23 | 	"path/filepath"
 24 | )
 25 | 
 26 | type (
 27 | 	FileState uint8
 28 | 
 29 | 	FileResets map[FileState]bool
 30 | 
 31 | 	FilePath struct {
 32 | 		Base, DstDir, Relative string
 33 | 	}
 34 | 
 35 | 	ByteRange struct {
 36 | 		Start, End, Offset int64
 37 | 		Indeterminate      bool
 38 | 	}
 39 | 
 40 | 	FileIO struct {
 41 | 		*os.File
 42 | 		Scope  ByteRange
 43 | 		State  FileState
 44 | 		Path   FilePath
 45 | 		Oflag  int
 46 | 		Perm   os.FileMode
 47 | 		isOpen bool
 48 | 	}
 49 | 
 50 | 	FileIOs []*FileIO
 51 | )
 52 | 
 53 | const (
 54 | 	New FileState = iota
 55 | 	Resume
 56 | 	Completed
 57 | 	Broken
 58 | 	Unknown
 59 | 
 60 | 	FilePerm os.FileMode = 0644
 61 | 
 62 | 	UnknownSize   = -1
 63 | 	PathSeparator = string(os.PathSeparator)
 64 | )
 65 | 
 66 | func BuildFileIOs(partCount int, base string, dirs []string) (FileIOs, error) {
 67 | 
 68 | 	if dirs == nil {
 69 | 		dirs = []string{""}
 70 | 	}
 71 | 
 72 | 	fios := make(FileIOs, partCount)
 73 | 	dirCount := len(dirs)
 74 | 	perDir := partCount / dirCount
 75 | 	remainer := partCount % dirCount
 76 | 	addIndex := FileNameIndexer(partCount)
 77 | 
 78 | 	var i, e int
 79 | 	for _, d := range dirs {
 80 | 
 81 | 		if e = 0; remainer > 0 {
 82 | 			e = 1
 83 | 			remainer--
 84 | 		}
 85 | 
 86 | 		for range perDir + e {
 87 | 
 88 | 			fio, err := NewFileIO(addIndex(base), d, os.O_CREATE|os.O_WRONLY)
 89 | 			if err != nil {
 90 | 				return nil, err
 91 | 			}
 92 | 			fios[i] = fio
 93 | 			i++
 94 | 
 95 | 		}
 96 | 
 97 | 	}
 98 | 
 99 | 	return fios, nil
100 | 
101 | }
102 | 
103 | func NewFileIO(base, dir string, oflag int) (*FileIO, error) {
104 | 
105 | 	var relv string
106 | 
107 | 	switch {
108 | 	case dir == "":
109 | 		relv = filepath.Clean(base)
110 | 	default:
111 | 		relv = filepath.Clean(dir + PathSeparator + base)
112 | 	}
113 | 
114 | 	f, err := os.OpenFile(relv, oflag, FilePerm)
115 | 
116 | 	if err != nil {
117 | 		return nil, err
118 | 	}
119 | 
120 | 	return &FileIO{
121 | 		File: f,
122 | 		Path: FilePath{
123 | 			Base:     base,
124 | 			DstDir:   dir,
125 | 			Relative: relv,
126 | 		},
127 | 		Oflag:  oflag,
128 | 		Perm:   FilePerm,
129 | 		isOpen: true,
130 | 	}, nil
131 | 
132 | }
133 | 
134 | func (fio *FileIO) DataCast(br ByteRange) (io.ReadCloser, error) {
135 | 
136 | 	rangeStart := br.Start + br.Offset
137 | 	rangeEnd := br.End
138 | 
139 | 	if rangeEnd < 0 {
140 | 		rangeEnd = 0
141 | 	}
142 | 
143 | 	if rangeStart > rangeEnd || rangeStart < 0 {
144 | 		rangeStart = rangeEnd
145 | 	}
146 | 
147 | 	r := io.NewSectionReader(fio, rangeStart, rangeEnd-rangeStart+1)
148 | 
149 | 	return io.NopCloser(r), nil
150 | 
151 | }
152 | 
153 | func NewFileDataCaster(path string) (DataCaster, error) {
154 | 
155 | 	f, err := os.Open(path)
156 | 	if err != nil {
157 | 		return nil, err
158 | 	}
159 | 
160 | 	return &FileIO{
161 | 		File: f,
162 | 		Path: FilePath{
163 | 			Base: path,
164 | 		},
165 | 		isOpen: true,
166 | 	}, nil
167 | 
168 | }
169 | 
170 | func (fios FileIOs) RenewByState(fr FileResets) error {
171 | 
172 | 	for _, fio := range fios {
173 | 
174 | 		if fio.State == Unknown || (fr != nil && fr[fio.State]) {
175 | 
176 | 			if err := fio.Open(); err != nil {
177 | 				return err
178 | 			}
179 | 			if err := fio.File.Truncate(0); err != nil {
180 | 				return err
181 | 			}
182 | 			if fio.State != Unknown {
183 | 				fio.State = New
184 | 			}
185 | 			fio.Scope.Offset = 0
186 | 
187 | 		}
188 | 
189 | 	}
190 | 	return nil
191 | 
192 | }
193 | 
194 | func (fios FileIOs) SetInitialState() error {
195 | 
196 | 	for _, fio := range fios {
197 | 		size, err := fio.Size()
198 | 		if err != nil {
199 | 			return err
200 | 		}
201 | 
202 | 		rs := fio.Scope.Start
203 | 		re := fio.Scope.End
204 | 
205 | 		switch {
206 | 		case rs == UnknownSize || re == UnknownSize:
207 | 			fio.State = Unknown
208 | 		case rs > re:
209 | 			fio.State = Broken
210 | 		case size > re-rs+1:
211 | 			fio.State = Broken
212 | 		case size == re-rs+1:
213 | 			fio.State = Completed
214 | 		case size > 0:
215 | 			fio.State = Resume
216 | 		default:
217 | 			fio.State = New
218 | 		}
219 | 	}
220 | 	return nil
221 | 
222 | }
223 | 
224 | func (fios FileIOs) SetByteRange(dataSize int64, partSize int64) error {
225 | 
226 | 	if dataSize < 0 {
227 | 		for _, fio := range fios {
228 | 			fio.Scope.Start = 1 // end - start + 1 = -1
229 | 			fio.Scope.End = UnknownSize
230 | 		}
231 | 		return nil
232 | 	}
233 | 
234 | 	if partSize > 0 {
235 | 		if err := fios.setByteRangeByPartSize(dataSize, partSize); err != nil {
236 | 			return err
237 | 		}
238 | 	} else {
239 | 		if err := fios.setByteRangeByPartCount(dataSize); err != nil {
240 | 			return err
241 | 		}
242 | 	}
243 | 
244 | 	return nil
245 | 
246 | }
247 | 
248 | func (fios FileIOs) setByteRangeByPartCount(dataSize int64) error {
249 | 
250 | 	var rangeStart, rangeEnd, offset, e int64
251 | 
252 | 	partCount := len(fios)
253 | 	basePartSize := dataSize / int64(partCount)
254 | 	remainder := dataSize % int64(partCount)
255 | 
256 | 	var i int
257 | 	for i, offset = 0, 0; i < partCount; i, offset = i+1, offset+basePartSize {
258 | 
259 | 		if e = 0; remainder > 0 {
260 | 			e = 1
261 | 			remainder--
262 | 		}
263 | 
264 | 		rangeStart = offset
265 | 		rangeEnd = (rangeStart - 1) + basePartSize + e
266 | 		offset = offset + e
267 | 
268 | 		fio := fios[i]
269 | 
270 | 		fio.Scope.Start = rangeStart
271 | 		fio.Scope.End = rangeEnd
272 | 
273 | 		if size, err := fio.Size(); err != nil {
274 | 			return err
275 | 		} else {
276 | 			fio.Scope.Offset = size
277 | 		}
278 | 
279 | 	}
280 | 
281 | 	return nil
282 | 
283 | }
284 | 
285 | func (fios FileIOs) setByteRangeByPartSize(dataSize, partSize int64) error {
286 | 
287 | 	var rangeStart, rangeEnd, offset int64
288 | 
289 | 	partCount := 1 + int((dataSize-1)/partSize) //ceiling division
290 | 
291 | 	var i int
292 | 	for i, offset = 0, 0; i < partCount; i, offset = i+1, offset+partSize {
293 | 
294 | 		if i+1 == partCount {
295 | 			rangeStart = offset
296 | 			rangeEnd = dataSize - 1
297 | 		} else {
298 | 			rangeStart = offset
299 | 			rangeEnd = (rangeStart - 1) + partSize
300 | 		}
301 | 
302 | 		fio := fios[i]
303 | 
304 | 		fio.Scope.Start = rangeStart
305 | 		fio.Scope.End = rangeEnd
306 | 
307 | 		if size, err := fio.Size(); err != nil {
308 | 			return err
309 | 		} else {
310 | 			fio.Scope.Offset = size
311 | 		}
312 | 
313 | 	}
314 | 
315 | 	return nil
316 | 
317 | }
318 | 
319 | func newFileNameFromPath(path string) string {
320 | 
321 | 	return filepath.Base(path)
322 | 
323 | }
324 | 
325 | func FileNameIndexer(maxIndex int) func(string) string {
326 | 
327 | 	if maxIndex <= 1 {
328 | 		return func(name string) string {
329 | 			return name
330 | 		}
331 | 	}
332 | 	countDigits := func(n int) int {
333 | 		count := 0
334 | 		switch {
335 | 		case n == 0:
336 | 			return 1
337 | 		case n < 0:
338 | 			n = -n
339 | 		}
340 | 
341 | 		for n > 0 {
342 | 			n /= 10
343 | 			count++
344 | 		}
345 | 		return count
346 | 	}
347 | 	pad := countDigits(maxIndex)
348 | 	currentIndex := 0
349 | 
350 | 	return func(name string) string {
351 | 		if currentIndex < maxIndex {
352 | 			currentIndex++
353 | 			return fmt.Sprintf("%s_%0*d", name, pad, currentIndex)
354 | 		}
355 | 		return name
356 | 	}
357 | 
358 | }
359 | 
360 | func (s FileState) String() string {
361 | 
362 | 	switch s {
363 | 	case New:
364 | 		return "new"
365 | 	case Resume:
366 | 		return "resume"
367 | 	case Completed:
368 | 		return "completed"
369 | 	case Broken:
370 | 		return "broken"
371 | 	default:
372 | 		return "unknown"
373 | 	}
374 | 
375 | }
376 | 
377 | func (fio *FileIO) Size() (int64, error) {
378 | 
379 | 	info, err := os.Stat(fio.Path.Relative)
380 | 	if err != nil {
381 | 		return UnknownSize, nil
382 | 	}
383 | 	return info.Size(), nil
384 | 
385 | }
386 | 
387 | func (fios FileIOs) TotalSize() int64 {
388 | 
389 | 	var totalSize, size int64
390 | 
391 | 	for _, fio := range fios {
392 | 		size, _ = fio.Size()
393 | 		totalSize += size
394 | 	}
395 | 	return totalSize
396 | 
397 | }
398 | 
399 | func (fio *FileIO) SetOffset() error {
400 | 
401 | 	if fio.State == Unknown {
402 | 
403 | 		if err := fio.Truncate(0); err != nil {
404 | 			return err
405 | 		}
406 | 		fio.Seek(0, io.SeekEnd)
407 | 		fio.Scope.Offset = 0
408 | 		return nil
409 | 
410 | 	}
411 | 
412 | 	if size, err := fio.Size(); err != nil {
413 | 		return err
414 | 	} else {
415 | 		fio.Scope.Offset = size
416 | 	}
417 | 	return nil
418 | 
419 | }
420 | 
421 | func (fio *FileIO) IsOpen() bool {
422 | 
423 | 	mtx.Lock()
424 | 	defer mtx.Unlock()
425 | 	return fio.isOpen
426 | 
427 | }
428 | 
429 | func (fio *FileIO) Open() (err error) {
430 | 
431 | 	if fio.isOpen {
432 | 		return nil
433 | 	}
434 | 
435 | 	fio.File, err = os.OpenFile(fio.Path.Relative, fio.Oflag, fio.Perm)
436 | 	if err != nil {
437 | 		return err
438 | 	}
439 | 
440 | 	return nil
441 | 
442 | }
443 | 
444 | func (fio *FileIO) Close() error {
445 | 
446 | 	mtx.Lock()
447 | 	defer mtx.Unlock()
448 | 
449 | 	if !fio.isOpen {
450 | 		return nil
451 | 	}
452 | 
453 | 	fio.isOpen = false
454 | 	if fio.File != nil {
455 | 		if err := fio.File.Close(); err != nil {
456 | 			return err
457 | 		}
458 | 	}
459 | 	return nil
460 | 
461 | }
462 | 
463 | func (fio *FileIO) Truncate(size int64) error {
464 | 
465 | 	if err := fio.Open(); err != nil {
466 | 		return err
467 | 	}
468 | 
469 | 	mtx.Lock()
470 | 	defer mtx.Unlock()
471 | 
472 | 	if err := fio.File.Truncate(size); err != nil {
473 | 		return err
474 | 	}
475 | 
476 | 	return nil
477 | 
478 | }
479 | 
480 | func (fio *FileIO) PullState() FileState {
481 | 
482 | 	mtx.Lock()
483 | 	defer mtx.Unlock()
484 | 	return fio.State
485 | 
486 | }
487 | 
488 | func (fio *FileIO) PushState(fs FileState) {
489 | 
490 | 	mtx.Lock()
491 | 	defer mtx.Unlock()
492 | 	fio.State = fs
493 | 
494 | }
495 | 


--------------------------------------------------------------------------------
/flow.go:
--------------------------------------------------------------------------------
 1 | /*
 2 | Copyright 2024 Carlo Jay I. Jacaba
 3 | 
 4 | Licensed under the Apache License, Version 2.0 (the "License");
 5 | you may not use this file except in compliance with the License.
 6 | You may obtain a copy of the License at
 7 | 
 8 | 	http://www.apache.org/licenses/LICENSE-2.0
 9 | 
10 | Unless required by applicable law or agreed to in writing, software
11 | distributed under the License is distributed on an "AS IS" BASIS,
12 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | See the License for the specific language governing permissions and
14 | limitations under the License.
15 | */
16 | 
17 | package partdec
18 | 
19 | import (
20 | 	"sync"
21 | )
22 | 
23 | type FlowControl struct {
24 | 	WG      *sync.WaitGroup
25 | 	Limiter chan struct{}
26 | }
27 | 
28 | var mtx = &sync.Mutex{}
29 | 
30 | func NewFlowControl(limit int) *FlowControl {
31 | 
32 | 	return &FlowControl{
33 | 		WG:      &sync.WaitGroup{},
34 | 		Limiter: make(chan struct{}, limit),
35 | 	}
36 | 
37 | }
38 | 
39 | func (fc *FlowControl) Acquire() {
40 | 	fc.Limiter <- struct{}{}
41 | }
42 | 
43 | func (fc *FlowControl) Release() {
44 | 	<-fc.Limiter
45 | }
46 | 


--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
 1 | module github.com/cjijcb/partdec
 2 | 
 3 | go 1.22.8
 4 | 
 5 | require (
 6 | 	golang.org/x/sys v0.26.0
 7 | 	golang.org/x/term v0.25.0
 8 | )
 9 | 
10 | require github.com/spf13/pflag v1.0.5
11 | 


--------------------------------------------------------------------------------
/go.sum:
--------------------------------------------------------------------------------
1 | github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
2 | github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
3 | golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo=
4 | golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
5 | golang.org/x/term v0.25.0 h1:WtHI/ltw4NvSUig5KARz9h521QvRC8RmF/cuYqifU24=
6 | golang.org/x/term v0.25.0/go.mod h1:RPyXicDX+6vLxogjjRxjgD2TKtmAO6NZBsBRfrOLu7M=
7 | 


--------------------------------------------------------------------------------
/httpio.go:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright 2024 Carlo Jay I. Jacaba
  3 | 
  4 | Licensed under the Apache License, Version 2.0 (the "License");
  5 | you may not use this file except in compliance with the License.
  6 | You may obtain a copy of the License at
  7 | 
  8 |     http://www.apache.org/licenses/LICENSE-2.0
  9 | 
 10 | Unless required by applicable law or agreed to in writing, software
 11 | distributed under the License is distributed on an "AS IS" BASIS,
 12 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 | See the License for the specific language governing permissions and
 14 | limitations under the License.
 15 | */
 16 | 
 17 | package partdec
 18 | 
 19 | import (
 20 | 	"fmt"
 21 | 	"io"
 22 | 	"mime"
 23 | 	"net/http"
 24 | 	"net/url"
 25 | 	"path"
 26 | )
 27 | 
 28 | type (
 29 | 	HTTPIO struct {
 30 | 		*http.Client
 31 | 		*http.Request
 32 | 		Body   io.ReadCloser
 33 | 		isOpen bool
 34 | 	}
 35 | )
 36 | 
 37 | const (
 38 | 	UserAgent = "partdec/0.4.2"
 39 | )
 40 | 
 41 | var (
 42 | 	SharedTransport = &http.Transport{
 43 | 		MaxIdleConnsPerHost: MaxConcurrentFetch,
 44 | 		DisableKeepAlives:   false,
 45 | 	}
 46 | 
 47 | 	SharedHeader = http.Header{
 48 | 		"Accept":     []string{"*/*"},
 49 | 		"User-Agent": []string{UserAgent},
 50 | 	}
 51 | )
 52 | 
 53 | func NewHTTPIO(ct *http.Client, rawURL string) (*HTTPIO, error) {
 54 | 
 55 | 	req, err := http.NewRequest(http.MethodGet, rawURL, nil)
 56 | 	if err != nil {
 57 | 		return nil, err
 58 | 	}
 59 | 
 60 | 	req.Header = SharedHeader.Clone()
 61 | 
 62 | 	return &HTTPIO{
 63 | 		Client:  ct,
 64 | 		Request: req,
 65 | 		isOpen:  true,
 66 | 	}, nil
 67 | 
 68 | }
 69 | 
 70 | func (hio *HTTPIO) DataCast(br ByteRange) (io.ReadCloser, error) {
 71 | 
 72 | 	if !br.Indeterminate {
 73 | 		hio.Request.Header.Set("Range", BuildRangeHeader(br))
 74 | 	}
 75 | 
 76 | 	resp, err := hio.Client.Do(hio.Request)
 77 | 	if err != nil {
 78 | 		return nil, err
 79 | 	}
 80 | 
 81 | 	if !(resp.StatusCode >= 200 && resp.StatusCode <= 299) {
 82 | 		return nil, NewErr(resp.Status)
 83 | 	}
 84 | 
 85 | 	hio.Body = resp.Body
 86 | 
 87 | 	return hio.Body, nil
 88 | 
 89 | }
 90 | 
 91 | func NewHTTPDataCaster(rawURL string) (DataCaster, error) {
 92 | 
 93 | 	hio, err := NewHTTPIO(
 94 | 		&http.Client{Transport: SharedTransport},
 95 | 		rawURL,
 96 | 	)
 97 | 
 98 | 	if err != nil {
 99 | 		return nil, err
100 | 	}
101 | 
102 | 	return hio, nil
103 | 
104 | }
105 | 
106 | func (hio *HTTPIO) IsOpen() bool {
107 | 
108 | 	mtx.Lock()
109 | 	defer mtx.Unlock()
110 | 	return hio.isOpen
111 | 
112 | }
113 | 
114 | func (hio *HTTPIO) Close() error {
115 | 
116 | 	mtx.Lock()
117 | 	defer mtx.Unlock()
118 | 
119 | 	if !hio.isOpen {
120 | 		return nil
121 | 	}
122 | 
123 | 	hio.isOpen = false
124 | 	if hio.Body != nil {
125 | 		if err := hio.Body.Close(); err != nil {
126 | 			return err
127 | 		}
128 | 	}
129 | 	return nil
130 | 
131 | }
132 | 
133 | func BuildRangeHeader(br ByteRange) string {
134 | 
135 | 	if br.Start == UnknownSize || br.End == UnknownSize {
136 | 		return "none"
137 | 	}
138 | 
139 | 	rangeStart := br.Start + br.Offset
140 | 	rangeEnd := br.End
141 | 
142 | 	if rangeStart > rangeEnd {
143 | 		rangeStart = rangeEnd
144 | 	}
145 | 
146 | 	return fmt.Sprintf("bytes=%d-%d", rangeStart, rangeEnd)
147 | 
148 | }
149 | 
150 | func getRespInfo(rawURL *string, cl *int64) (http.Header, error) {
151 | 
152 | 	ct := &http.Client{
153 | 		Transport: SharedTransport,
154 | 		CheckRedirect: func(req *http.Request, via []*http.Request) error {
155 | 			*rawURL = req.URL.String()
156 | 			fmt.Fprintf(Stderr, "%s to: %s\n", ErrRedir, *rawURL)
157 | 			return nil
158 | 		},
159 | 	}
160 | 
161 | 	req, err := http.NewRequest(http.MethodHead, *rawURL, nil)
162 | 	if err != nil {
163 | 		return nil, err
164 | 	}
165 | 
166 | 	req.Header = SharedHeader
167 | 
168 | 	resp, err := ct.Do(req)
169 | 	if err == nil && resp.ContentLength != UnknownSize {
170 | 		*cl = resp.ContentLength
171 | 		return resp.Header, nil
172 | 	}
173 | 
174 | 	req.Method = http.MethodGet //fallback to GET request
175 | 	resp, err = ct.Do(req)
176 | 
177 | 	if err == nil {
178 | 		defer resp.Body.Close()
179 | 		*cl = resp.ContentLength
180 | 		return resp.Header, nil
181 | 	}
182 | 
183 | 	return nil, err
184 | 
185 | }
186 | 
187 | func newFileNameFromHeader(hdr http.Header) string {
188 | 
189 | 	if hdr == nil {
190 | 		return ""
191 | 	}
192 | 
193 | 	cd := hdr.Get("Content-Disposition")
194 | 	if cd == "" {
195 | 		return ""
196 | 	}
197 | 
198 | 	_, params, err := mime.ParseMediaType(cd)
199 | 	if err != nil {
200 | 		return ""
201 | 	}
202 | 
203 | 	fileName, ok := params["filename"]
204 | 	if !ok || fileName == "" {
205 | 		return ""
206 | 	}
207 | 
208 | 	return fileName
209 | 
210 | }
211 | 
212 | func newFileNameFromURL(rawURL string) string {
213 | 
214 | 	url, err := url.Parse(rawURL)
215 | 	if err != nil {
216 | 		return ""
217 | 	}
218 | 
219 | 	if url.Path != "" {
220 | 		return path.Base(url.Path)
221 | 	}
222 | 
223 | 	return "index.html"
224 | 
225 | }
226 | 


--------------------------------------------------------------------------------
/init_windows.go:
--------------------------------------------------------------------------------
 1 | //go:build windows
 2 | 
 3 | /*
 4 | Copyright 2024 Carlo Jay I. Jacaba
 5 | 
 6 | Licensed under the Apache License, Version 2.0 (the "License");
 7 | you may not use this file except in compliance with the License.
 8 | You may obtain a copy of the License at
 9 | 
10 |     http://www.apache.org/licenses/LICENSE-2.0
11 | 
12 | Unless required by applicable law or agreed to in writing, software
13 | distributed under the License is distributed on an "AS IS" BASIS,
14 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | See the License for the specific language governing permissions and
16 | limitations under the License.
17 | */
18 | 
19 | package partdec
20 | 
21 | import (
22 | 	"golang.org/x/sys/windows"
23 | 	"os"
24 | )
25 | 
26 | func init() {
27 | 	var originalMode uint32
28 | 
29 | 	stdout := windows.Handle(os.Stdout.Fd())
30 | 
31 | 	windows.GetConsoleMode(stdout, &originalMode)
32 | 	windows.SetConsoleMode(stdout, originalMode|windows.ENABLE_VIRTUAL_TERMINAL_PROCESSING)
33 | }
34 | 


--------------------------------------------------------------------------------
/input.go:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright 2024 Carlo Jay I. Jacaba
  3 | 
  4 | Licensed under the Apache License, Version 2.0 (the "License");
  5 | you may not use this file except in compliance with the License.
  6 | You may obtain a copy of the License at
  7 | 
  8 |     http://www.apache.org/licenses/LICENSE-2.0
  9 | 
 10 | Unless required by applicable law or agreed to in writing, software
 11 | distributed under the License is distributed on an "AS IS" BASIS,
 12 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 | See the License for the specific language governing permissions and
 14 | limitations under the License.
 15 | */
 16 | 
 17 | package partdec
 18 | 
 19 | import (
 20 | 	_ "embed"
 21 | 	"fmt"
 22 | 	flag "github.com/spf13/pflag"
 23 | 	"io"
 24 | 	"net/http"
 25 | 	"net/url"
 26 | 	"os"
 27 | 	"strconv"
 28 | 	"strings"
 29 | 	"time"
 30 | 	"unicode"
 31 | )
 32 | 
 33 | type (
 34 | 	header struct {
 35 | 		h http.Header
 36 | 	}
 37 | 
 38 | 	byteSize int64
 39 | 
 40 | 	options struct {
 41 | 		fs          *flag.FlagSet
 42 | 		part        int
 43 | 		size        byteSize
 44 | 		base        string
 45 | 		dir         []string
 46 | 		reset       FileResets
 47 | 		retry       int
 48 | 		timeout     time.Duration
 49 | 		header      header
 50 | 		noConnReuse bool
 51 | 		force       bool
 52 | 		quiet       bool
 53 | 		version     bool
 54 | 		help        bool
 55 | 	}
 56 | )
 57 | 
 58 | const (
 59 | 	Kibi = 1024
 60 | 	Mebi = 1024 * 1024
 61 | 	Gibi = 1024 * 1024 * 1024
 62 | 	Tebi = 1024 * 1024 * 1024 * 1024
 63 | 
 64 | 	Kilo = 1000
 65 | 	Mega = 1000 * 1000
 66 | 	Giga = 1000 * 1000 * 1000
 67 | 	Tera = 1000 * 1000 * 1000 * 1000
 68 | )
 69 | 
 70 | //go:embed docs/version_page
 71 | var VersionPage string
 72 | 
 73 | //go:embed docs/help_page
 74 | var HelpPage string
 75 | 
 76 | var (
 77 | 	ByteUnit = map[string]int64{
 78 | 		"":  1,
 79 | 		"B": 1,
 80 | 
 81 | 		"KIB": Kibi,
 82 | 		"MIB": Mebi,
 83 | 		"GIB": Gibi,
 84 | 		"TIB": Tebi,
 85 | 
 86 | 		"K": Kibi,
 87 | 		"M": Mebi,
 88 | 		"G": Gibi,
 89 | 		"T": Tebi,
 90 | 
 91 | 		"KB": Kilo,
 92 | 		"MB": Mega,
 93 | 		"GB": Giga,
 94 | 		"TB": Tera,
 95 | 	}
 96 | )
 97 | 
 98 | func NewDLOptions() (*DLOptions, error) {
 99 | 
100 | 	opt := &options{fs: flag.CommandLine}
101 | 
102 | 	opt.init()
103 | 	uri, err := opt.parse()
104 | 
105 | 	err = reqErrInfo(err)
106 | 
107 | 	if err != nil {
108 | 		return nil, err
109 | 	}
110 | 
111 | 	var ui func(*Download)
112 | 
113 | 	if opt.quiet || opt.force {
114 | 		ui = nil
115 | 	} else {
116 | 		ui = ShowProgress
117 | 	}
118 | 
119 | 	if opt.part > 1 || opt.size > 0 {
120 | 		opt.header.h.Del("Range")
121 | 	}
122 | 
123 | 	return &DLOptions{
124 | 		URI:       uri,
125 | 		BasePath:  opt.base,
126 | 		DstDirs:   opt.dir,
127 | 		PartCount: opt.part,
128 | 		PartSize:  int64(opt.size),
129 | 		ReDL:      opt.reset,
130 | 		UI:        ui,
131 | 		Force:     opt.force,
132 | 		Mod: &IOMod{
133 | 			Retry:       max(opt.retry, 0),
134 | 			Timeout:     opt.timeout,
135 | 			UserHeader:  opt.header.h,
136 | 			NoConnReuse: opt.noConnReuse,
137 | 		},
138 | 	}, nil
139 | 
140 | }
141 | 
142 | func (opt *options) init() {
143 | 
144 | 	opt.reset = map[FileState]bool{
145 | 		Broken: false, Completed: false, Resume: false,
146 | 	}
147 | 	opt.size = byteSize(UnknownSize)
148 | 	opt.header.h = make(http.Header)
149 | 
150 | 	fs := opt.fs
151 | 	fs.Init(os.Args[0], flag.ContinueOnError)
152 | 	fs.SetOutput(io.Discard)
153 | 	fs.Usage = func() {}
154 | 
155 | 	fs.IntVarP(&opt.part, "part", "p", 1, "")
156 | 
157 | 	fs.VarP(&opt.size, "size", "s", "")
158 | 
159 | 	fs.StringVarP(&opt.base, "base", "b", "", "")
160 | 
161 | 	fs.StringSliceVarP(&opt.dir, "dir", "d", []string{""}, "")
162 | 
163 | 	fs.VarP(&opt.reset, "reset", "z", "")
164 | 	flag.Lookup("reset").NoOptDefVal = "1,2,3"
165 | 
166 | 	fs.IntVarP(&opt.retry, "retry", "r", 5, "")
167 | 
168 | 	fs.DurationVarP(&opt.timeout, "timeout", "t", 0, "")
169 | 
170 | 	fs.VarP(&opt.header, "header", "H", "")
171 | 
172 | 	fs.BoolVarP(&opt.noConnReuse, "no-connection-reuse", "x", false, "")
173 | 
174 | 	fs.BoolVarP(&opt.force, "force", "f", false, "")
175 | 
176 | 	fs.BoolVarP(&opt.quiet, "quiet", "q", false, "")
177 | 
178 | 	fs.BoolVarP(&opt.version, "version", "V", false, "")
179 | 
180 | 	fs.BoolVarP(&opt.help, "help", "h", false, "")
181 | 
182 | }
183 | 
184 | func (opt *options) parse() (uri string, err error) {
185 | 
186 | 	fs := opt.fs
187 | 
188 | 	if err = fs.Parse(os.Args[1:]); err != nil {
189 | 		return "", err
190 | 	}
191 | 
192 | 	if opt.version {
193 | 		return "", ErrVer
194 | 	}
195 | 
196 | 	if opt.help {
197 | 		return "", flag.ErrHelp
198 | 	}
199 | 
200 | 	args := fs.Args()
201 | 
202 | 	switch len(args) {
203 | 	case 1:
204 | 		uri = args[0]
205 | 	case 0:
206 | 		return "", NewErr("%s\n%s", ErrArgs,
207 | 			"try 'partdec -h' for usage information")
208 | 	default:
209 | 		return "", NewErr("%s: %q", ErrArgs,
210 | 			strings.Join(args, " "))
211 | 	}
212 | 
213 | 	return uri, nil
214 | 
215 | }
216 | 
217 | func reqErrInfo(err error) error {
218 | 
219 | 	if err != nil {
220 | 		switch {
221 | 		case IsErr(err, ErrVer):
222 | 			fmt.Printf("%s", VersionPage)
223 | 		case IsErr(err, flag.ErrHelp):
224 | 			fmt.Printf("%s", HelpPage)
225 | 		default:
226 | 			fmt.Fprintf(Stderr, "%s\n", err)
227 | 		}
228 | 		return err
229 | 	}
230 | 	return nil
231 | 
232 | }
233 | 
234 | func (fr *FileResets) String() string {
235 | 	return fmt.Sprintf("%v", (*fr))
236 | }
237 | 
238 | func (fr *FileResets) Type() string {
239 | 	return "FileResets"
240 | }
241 | 
242 | func (fr *FileResets) Set(value string) error {
243 | 
244 | 	(*fr) = map[FileState]bool{
245 | 		Broken: false, Completed: false, Resume: false,
246 | 	}
247 | 
248 | 	opt := strings.SplitN(value, ",", 3)
249 | 
250 | 	for _, o := range opt {
251 | 
252 | 		switch strings.TrimSpace(o) {
253 | 		case "1":
254 | 			(*fr)[Resume] = true
255 | 		case "2":
256 | 			(*fr)[Completed] = true
257 | 		case "3":
258 | 			(*fr)[Broken] = true
259 | 		default:
260 | 			return ErrParse
261 | 		}
262 | 
263 | 	}
264 | 
265 | 	return nil
266 | 
267 | }
268 | 
269 | func (h *header) String() string {
270 | 	return fmt.Sprintf("%+v", h.h)
271 | }
272 | 
273 | func (h *header) Type() string {
274 | 	return "Header"
275 | }
276 | 
277 | func (h *header) Set(value string) error {
278 | 
279 | 	if kv := strings.SplitN(value, ":", 2); len(kv) > 1 {
280 | 
281 | 		h.h.Add(kv[0], strings.Trim(kv[1], " "))
282 | 	}
283 | 
284 | 	return nil
285 | 
286 | }
287 | 
288 | func (bs *byteSize) String() string {
289 | 	return fmt.Sprintf("%d", *bs)
290 | }
291 | 
292 | func (bs *byteSize) Type() string {
293 | 	return "ByteSize"
294 | }
295 | 
296 | func (bs *byteSize) Set(value string) error {
297 | 
298 | 	unitStr := strings.TrimLeftFunc(
299 | 		value,
300 | 		func(r rune) bool { return unicode.IsNumber(r) },
301 | 	)
302 | 
303 | 	byteStr := strings.TrimRightFunc(
304 | 		value,
305 | 		func(r rune) bool { return !unicode.IsNumber(r) },
306 | 	)
307 | 
308 | 	multiplier, found := ByteUnit[strings.ToUpper(unitStr)]
309 | 
310 | 	if !found {
311 | 		return ErrParse
312 | 	}
313 | 
314 | 	if byteCount, err := strconv.ParseInt(byteStr, 10, 64); err == nil {
315 | 		*bs = byteSize(byteCount * multiplier)
316 | 	} else {
317 | 		return err
318 | 	}
319 | 
320 | 	return nil
321 | 
322 | }
323 | 
324 | func IsFile(path string) bool {
325 | 
326 | 	if info, err := os.Stat(path); err == nil {
327 | 		return info.Mode().IsRegular()
328 | 	} else {
329 | 		return false
330 | 	}
331 | 
332 | }
333 | 
334 | func IsEndSeparator(path string) bool {
335 | 
336 | 	path = strings.TrimSpace(path)
337 | 	return path[len(path)-1:] == PathSeparator
338 | 
339 | }
340 | 
341 | func IsURL(rawURL string) bool {
342 | 
343 | 	if u, err := url.Parse(rawURL); err == nil {
344 | 		return (u.Scheme == "http" || u.Scheme == "https")
345 | 	} else {
346 | 		return false
347 | 	}
348 | 
349 | }
350 | 


--------------------------------------------------------------------------------
/third_party/spf13/pflag/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2012 Alex Ogier. All rights reserved.
 2 | Copyright (c) 2012 The Go Authors. All rights reserved.
 3 | 
 4 | Redistribution and use in source and binary forms, with or without
 5 | modification, are permitted provided that the following conditions are
 6 | met:
 7 | 
 8 |    * Redistributions of source code must retain the above copyright
 9 | notice, this list of conditions and the following disclaimer.
10 |    * Redistributions in binary form must reproduce the above
11 | copyright notice, this list of conditions and the following disclaimer
12 | in the documentation and/or other materials provided with the
13 | distribution.
14 |    * Neither the name of Google Inc. nor the names of its
15 | contributors may be used to endorse or promote products derived from
16 | this software without specific prior written permission.
17 | 
18 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 | 


--------------------------------------------------------------------------------
/ui.go:
--------------------------------------------------------------------------------
  1 | /*
  2 | Copyright 2024 Carlo Jay I. Jacaba
  3 | 
  4 | Licensed under the Apache License, Version 2.0 (the "License");
  5 | you may not use this file except in compliance with the License.
  6 | You may obtain a copy of the License at
  7 | 
  8 |     http://www.apache.org/licenses/LICENSE-2.0
  9 | 
 10 | Unless required by applicable law or agreed to in writing, software
 11 | distributed under the License is distributed on an "AS IS" BASIS,
 12 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 | See the License for the specific language governing permissions and
 14 | limitations under the License.
 15 | */
 16 | 
 17 | package partdec
 18 | 
 19 | import (
 20 | 	"fmt"
 21 | 	"golang.org/x/term"
 22 | 	"os"
 23 | 	"strings"
 24 | 	"time"
 25 | 	"unicode/utf8"
 26 | )
 27 | 
 28 | type (
 29 | 	textBlock struct {
 30 | 		b        *strings.Builder
 31 | 		height   int
 32 | 		width    int
 33 | 		hChanged bool
 34 | 		wChanged bool
 35 | 	}
 36 | 
 37 | 	report struct {
 38 | 		fios       FileIOs
 39 | 		dsize      int64
 40 | 		fileReport func(int) int
 41 | 		rateReport func() int
 42 | 		text       *textBlock
 43 | 		finalCh    chan struct{}
 44 | 		onesec     *time.Ticker
 45 | 		startTime  time.Time
 46 | 	}
 47 | )
 48 | 
 49 | const (
 50 | 	esc        rune = 27
 51 | 	clearToEnd      = string(esc) + "[0J"
 52 | 	hideCursor      = string(esc) + "[?25l"
 53 | 	showCursor      = string(esc) + "[?25h"
 54 | 	homeCursor      = string(esc) + "[H"
 55 | 	div             = "----------------------------------------"
 56 | )
 57 | 
 58 | var (
 59 | 	upLine = func(n int) string { return fmt.Sprintf("%c[%dF", esc, n) }
 60 | )
 61 | 
 62 | func ShowProgress(d *Download) {
 63 | 
 64 | 	defer d.Flow.WG.Done()
 65 | 	defer d.Stop()
 66 | 
 67 | 	r := newReport(d.Files, d.DataSize)
 68 | 	defer r.flush()
 69 | 
 70 | 	interrupted := false
 71 | 	fmt.Print(hideCursor)
 72 | 	var resetDisplay string
 73 | 	for {
 74 | 
 75 | 		select {
 76 | 		case <-d.Ctx.Done():
 77 | 			interrupted = true
 78 | 		default:
 79 | 			fmt.Print(r.show())
 80 | 			switch {
 81 | 			case !r.text.wChanged:
 82 | 				resetDisplay = upLine(r.text.height)
 83 | 			case r.text.hChanged:
 84 | 				resetDisplay = homeCursor
 85 | 				fallthrough
 86 | 			default:
 87 | 				resetDisplay += clearToEnd
 88 | 			}
 89 | 		}
 90 | 
 91 | 		if interrupted {
 92 | 			break
 93 | 		}
 94 | 
 95 | 		time.Sleep(200 * time.Millisecond)
 96 | 		fmt.Print(resetDisplay)
 97 | 	}
 98 | 
 99 | 	close(r.finalCh)
100 | 	fmt.Print(r.show() + showCursor)
101 | 
102 | }
103 | 
104 | func (r *report) show() string {
105 | 
106 | 	defer r.text.b.Reset()
107 | 
108 | 	width := termWidth()
109 | 
110 | 	fmt.Fprintf(r.text.b, "%-*s\n", width, div)
111 | 	lineCount := 1
112 | 
113 | 	lineCount += r.fileReport(width)
114 | 
115 | 	fmt.Fprintf(r.text.b, "%s\n", div)
116 | 	lineCount += 1
117 | 
118 | 	lineCount += r.rateReport()
119 | 
120 | 	r.text.hChanged = (r.text.height != lineCount)
121 | 	r.text.wChanged = (r.text.width != width)
122 | 
123 | 	r.text.height = lineCount
124 | 	r.text.width = width
125 | 
126 | 	return r.text.b.String()
127 | 
128 | }
129 | 
130 | func newReport(fios FileIOs, dataSize int64) *report {
131 | 
132 | 	tb := &textBlock{
133 | 		b:      new(strings.Builder),
134 | 		height: len(fios) + 3, //2 div plus 1 rate report
135 | 		width:  termWidth(),
136 | 	}
137 | 
138 | 	r := &report{
139 | 		fios:      fios,
140 | 		dsize:     dataSize,
141 | 		text:      tb,
142 | 		finalCh:   make(chan struct{}, 1),
143 | 		onesec:    time.NewTicker(time.Second),
144 | 		startTime: time.Now(),
145 | 	}
146 | 
147 | 	r.rateReport = r.rateReporter()
148 | 	r.fileReport = r.fileReporter()
149 | 	return r
150 | 
151 | }
152 | 
153 | func (r *report) rateReporter() func() int {
154 | 
155 | 	var bytes, cachedTotal int64
156 | 	var percent float32
157 | 
158 | 	rateReport := new(string)
159 | 
160 | 	refresh := func(final bool) {
161 | 		currentTotal := r.fios.TotalSize()
162 | 		if r.dsize > 0 {
163 | 			percent = (float32(currentTotal) / float32(r.dsize)) * 100
164 | 		}
165 | 		if !final || bytes == 0 {
166 | 			bytes = currentTotal - cachedTotal
167 | 			cachedTotal = currentTotal
168 | 		}
169 | 		*rateReport = fmt.Sprintf("%6.2f%%  |%12s%s  |  %-6s",
170 | 			percent,
171 | 			toEIC(bytes), "/s",
172 | 			r.elapsed(),
173 | 		)
174 | 	}
175 | 
176 | 	refresh(true)
177 | 	return func() int {
178 | 		select {
179 | 		case <-r.onesec.C:
180 | 			refresh(false)
181 | 			fmt.Fprintf(r.text.b, "%s\n", *rateReport)
182 | 		case <-r.finalCh:
183 | 			refresh(true)
184 | 			fmt.Fprintf(r.text.b, "%s\n", *rateReport)
185 | 		default:
186 | 			fmt.Fprintf(r.text.b, "%s\n", *rateReport)
187 | 		}
188 | 		return 1
189 | 	}
190 | 
191 | }
192 | 
193 | func (r *report) fileReporter() func(int) int {
194 | 
195 | 	csize := len(r.fios)
196 | 	cachedPartSize := make([]string, csize)
197 | 	cachedPath := make([]string, csize)
198 | 	cachedRuneCount := make([]int, csize)
199 | 
200 | 	for i, fio := range r.fios {
201 | 		ps := (fio.Scope.End - fio.Scope.Start) + 1
202 | 		pt := fio.Path.Relative
203 | 		cachedPartSize[i] = toEIC(ps)
204 | 		cachedPath[i] = pt
205 | 		cachedRuneCount[i] = utf8.RuneCountInString(pt) + 36
206 | 	}
207 | 
208 | 	return func(width int) (lineCount int) {
209 | 		for i, fio := range r.fios {
210 | 			size, _ := fio.Size()
211 | 			path := cachedPath[i]
212 | 			runeCount := cachedRuneCount[i]
213 | 
214 | 			pad := 0
215 | 			if width >= runeCount {
216 | 				pad = width - runeCount
217 | 			} else if width > 0 {
218 | 				lineCount += runeCount / width
219 | 			}
220 | 
221 | 			fmt.Fprintf(r.text.b,
222 | 				"%-9s->%11s/%-11s| %-*s\n", //36 chars minus path
223 | 				fio.PullState().String(),
224 | 				toEIC(size),
225 | 				cachedPartSize[i],
226 | 				pad,
227 | 				path,
228 | 			)
229 | 			lineCount++
230 | 
231 | 		}
232 | 		return lineCount
233 | 	}
234 | 
235 | }
236 | 
237 | func (r *report) elapsed() (elapsed string) {
238 | 
239 | 	t := time.Since(r.startTime)
240 | 	h := int(t.Hours())
241 | 	m := int(t.Minutes()) % 60
242 | 	s := int(t.Seconds()) % 60
243 | 
244 | 	if h > 0 {
245 | 		elapsed += fmt.Sprintf("%dh", h)
246 | 	}
247 | 	if m > 0 {
248 | 		elapsed += fmt.Sprintf("%dm", m)
249 | 	}
250 | 	if s > 0 || elapsed == "" {
251 | 		elapsed += fmt.Sprintf("%ds", s)
252 | 	}
253 | 
254 | 	return elapsed
255 | 
256 | }
257 | 
258 | func toEIC(b int64) string {
259 | 
260 | 	switch {
261 | 	case b < 0:
262 | 		return fmt.Sprintf("unknown")
263 | 	case b < Kibi:
264 | 		return fmt.Sprintf("%d B", b)
265 | 	case b >= Kibi && b < Mebi:
266 | 		return fmt.Sprintf("%.2f KiB", float32(b)/Kibi)
267 | 	case b >= Mebi && b < Gibi:
268 | 		return fmt.Sprintf("%.2f MiB", float32(b)/Mebi)
269 | 	case b >= Gibi && b < Tebi:
270 | 		return fmt.Sprintf("%.2f GiB", float32(b)/Gibi)
271 | 	default:
272 | 		return fmt.Sprintf("%.2f TiB", float32(b)/Tebi)
273 | 	}
274 | 
275 | }
276 | 
277 | func termWidth() int {
278 | 	width, _, _ := term.GetSize(int(os.Stdin.Fd()))
279 | 	return width
280 | }
281 | 
282 | func (r *report) flush() {
283 | 	r.onesec.Stop()
284 | }
285 | 


--------------------------------------------------------------------------------