标签: chunks

我想上传一个大文件curl。为此，我想将其拆分，而不将其保存到磁盘（就像使用split）。--continue-at我尝试与 一起使用Content-Length。

curl -s \
      --request PATCH \
      --header "Content-Type: application/offset+octet-stream" \
      --header "Content-Length: ${length}" \
      --header "Upload-Offset: ${offset}" \
      --continue-at "${offset}" \
      --upload-file "${file}" \
      "${dest}"

但curl“过冲”并忽略了Content-Length。有类似的东西--stop-at吗？或者，如果有必要，我必须使用dd。

编辑 dd解决方案：

curl -s \
      --request PATCH \
      --header "Content-Type: application/offset+octet-stream" \
      --header "Content-Length: ${length}" \
      --header "Upload-Offset: ${offset}" \
      --data-binary "@-" \
      "${dest}" < <(dd if=${file} skip=${offset} count=${length} iflag=skip_bytes,count_bytes 2>/dev/null)

但如果可能的话我想只使用 cURL..

语境

我们有一个批处理作业，可将本地化的国家/地区名称（即国家/地区名称翻译成不同语言）从外部数据库复制到我们的数据库。这个想法是在一个块中处理一个国家的所有本地化国家名称（即第一个块 - 安道尔的所有翻译，下一个块 - 阿联酋的所有翻译，等等）。我们JdbcCursorItemReader用于读取外部数据+一些oracle分析函数来提供该国可用的翻译总数：类似

select country_code, language_code, localized_name, COUNT(1) OVER(PARTITION BY c_lng.country_code) as lng_count
from EXT_COUNTRY_LNG c_lng
order by c_lng.countty_code, c_lng.language_code

问题

因此，按块切割此输入看起来很简单：当您读取了 中指定的确切行数时停止块lng_count并使用下一个读取行开始一个新的行，但实际上似乎并不那么简单:(

首先要尝试的是自定义完成策略。但问题是，它无权访问最后一个项目，读取者ItemReader- 您应该明确地将其置于阅读器的上下文中，并将其恢复到策略中。不喜欢它，因为它需要额外的阅读器修改/添加阅读器侦听器。此外，我不喜欢来回序列化/反序列化同一个项目。而且我不觉得JobContext/StepContext是存放此类数据的好地方。

还有RepeatContext，它看起来像这样的数据一个更好的地方，但我没能得到它容易...

所以最后我们得到了这样的解决方案：

@Bean(name = "localizedCountryNamesStep")
@JobScope
public Step insertCountryStep(
        final StepBuilderFactory stepBuilderFactory,
        final MasterdataCountryNameReader countryNameReader,
        final MasterdataCountryNameProcessor countryNameProcessor,
        final MasterdataCountryNameWriter writer) {
    /* Use the same fixed-commit policy, but update it's chunk size dynamically */
    final SimpleCompletionPolicy policy …

如果我的csv文件太大而无法使用大熊猫（在本例中为35gb）加载到内存中，那么我知道可以使用块大小对文件进行分块处理。

但是我想知道是否可以根据列中的值更改块大小。

我有一个ID列，然后每个ID都有几行包含信息，如下所示：

ID,   Time,  x, y
sasd, 10:12, 1, 3
sasd, 10:14, 1, 4
sasd, 10:32, 1, 2
cgfb, 10:02, 1, 6
cgfb, 10:13, 1, 3
aenr, 11:54, 2, 5
tory, 10:27, 1, 3
tory, 10:48, 3, 5
ect...

我不想将ID分成不同的块。例如，将处理大小为4的块：

ID,   Time,  x, y
sasd, 10:12, 1, 3
sasd, 10:14, 1, 4
sasd, 10:32, 1, 2
cgfb, 10:02, 1, 6
cgfb, 10:13, 1, 3 <--this extra line is included in the 4 chunk

ID,   Time,  x, y
aenr, 11:54, …

我需要在多个线程中逐块下载文件。例如，我有 1k 个文件，每个文件 ~100Mb-1Gb，我只能按 4096Kb 的块下载这些文件（每个 http get 请求只给我 4kb）。

在一个线程中下载它可能会很长，所以我想下载它们，假设在 20 个线程中（一个文件一个线程），我还需要在每个线程中同时下载几个块。

是否有任何示例可以显示这种逻辑？

我目前有一个使用MediaRecorder录制的MediaStream.在recorder.stop()之后的录制结束时,它会产生一个Blob,我可以播放该视频.我的目标是在最后播放整个视频,但在录制时播放一大块.目前,在录制结束时无法播放块.

我怎么能用javascript做到这一点？最终目标是通过websocket发送一个块,即使录制正在进行中也可以播放.

我无法提供新的解决方案.任何人都可以帮助或至少向我解释这些事情吗？

我试过的是

                navigator.mediaDevices.getUserMedia().then(function(media_stream) {
                    var recorder = new MediaRecorder(media_stream);

                    recorder.ondataavailable = event => {
                        //How to play each chunk without waiting for recorder.stop() ???
                        //event.data represent the data of a chunk (i.e. a blob)
                    };

                    recorder.start(1000);
                });

我有一个大文件，我想将其上传到服务器端。当发生任何问题（例如互联网中断或断电...）时，如果我重试上传，从简历上传的文件并且不需要从头开始发送文件，这一点非常重要。

我尝试使用这种方法发送文件块，但这似乎不是一个好方法，因为直接在响应实体中发送块（字节数组），这不是一个好主意。

不管怎样，如果有人可以开发这种方法并使该代码成为具有更好性能的更好代码，我对此表示赞赏。有人知道这样做的 最佳实践方法吗？

如果你喜欢我的代码，请投票给我，谢谢:)

休息控制器

@RestController
@RequestMapping("/files")
public class Controller {

@Autowired
private MyService service;

@PutMapping("/upload/resume")
public Mono<ResponseEntity> uploadWithResume(@RequestPart("chunk")byte[] chunk,
                                             @RequestPart("fileName")String fileName,
                                             @RequestParam("length")Long length
) throws ParseException {
    try {
        return service.fileResumeUpload(chunk, fileName, length);
    } catch (IOException e) {
        e.printStackTrace();
        return Mono.just(ResponseEntity.status(HttpStatus.PERMANENT_REDIRECT).build());
    }
}

@RequestMapping(value = "/get/uploaded/size", method = RequestMethod.HEAD)
public Mono<ResponseEntity> getUploadedSize(@RequestParam("fileName") String fileName) throws IOException {
    if (Files.exists(Paths.get("src/main/resources/" + fileName))) {

        String size = String.valueOf(Files.size(Paths.get("src/main/resources/" + fileName)));

        return Mono.just(ResponseEntity.ok()
                .header("upload-offset", size)
                .build());
    } …

我在使用 Webpack 4 时遇到问题，尝试使用异步块预加载一些数据，然后在加载数据时，将使用 webpack 计算的其他块附加到 dom。

两个块都使用同一个实例（单例），一次在加载数据时作为容器，另一次则读取这些加载的数据。

我希望它尽可能清楚。它与 Webpack 3 一起工作，可能是我们 6 个多月以来的运气，但我们今天迁移到了 webpack 4，症状非常明显：

• 在第一个块中，在加载数据时，会创建并填充实例。当尝试在这种情况下使用数据时，似乎没问题。
• 在第二个块中，加载后，实例不存在或未填充。

我在我的 Angular 应用程序中实现了延迟加载（使用 CLI 7.3.4）

它编译成功，但是当我路由到延迟加载的模块（比如 module1 路径）时，它再加载一个块，这实际上是其他延迟加载的模块（Module2）路径。

块名称：“../default~lazy-load-modules-module1-module1-module~lazy-load-modules-module2-mo~be6d77c5.js”

我无法理解为什么会生成这个默认值 ~。

我期望仅在调用其组件之一时加载模块。

我正在使用chuncksize（pandas DataFrame）读取一个大的csv文件，就像这样

reader = pd.read_csv('log_file.csv', low_memory = False, chunksize = 4e7)

我知道我可以只计算它在文件中读取的块数，但我想自动执行此操作并将块数保存到变量中，就像这样（以伪代码）

number_of_chuncks = countChuncks(reader)

有任何想法吗？

我需要将一个大文件（14 GB）分成较小的文件。该文件的格式为txt，制表符为“;” 我知道它有 70 列（字符串、双精度）。我想读取 100 万个并将它们保存在不同的文件中，file1，file2 ... fileN。

在@MKR的帮助下

但过程非常慢，我尝试使用 fread，但这是不可能的。

我该如何优化这段代码？

新代码

chunkSize <- 10000
conex <- file(description = db, open = "r")
data <- read.table(conex, nrows = chunkSize, header=T, fill=TRUE, sep =";")

index <- 0
counter <- 0
total <- 0
chunkSize <- 500000 
conex <- file(description=db,open="r")   
dataChunk <- read.table(conex, nrows=chunkSize, header=T, fill=TRUE,sep=";")

repeat {
dataChunk <- read.table(conex, nrows=chunkSize, header=FALSE, fill = TRUE, sep=";", col.names=db_colnames)
total <- total + sum(dataChunk$total)
counter <- counter + nrow(dataChunk)
write.table(dataChunk, file …