java程序: 从kernel.ubuntu.com下载kernel - HttpURLConnection

用java实现从kernel.ubuntu.com下载内核的小工具

现在的最新的LTS版本是4.19，目前已经更新到4.19.13了。

Kernel的更新通知里，经常有下面的陈述：

　　

作为一个听劝的人，没事就刷一刷https://www.kernel.org/，看看有没有更新。

有更新之后，再刷一刷kernel.ubuntu.com看看Ubuntu有没有更新内核。

下载deb包，执行下面安装内核之后在重启。

sudo dpkg -i *.deb

思路

希望通过下面命令行，可以从kernel.ubuntu.com下载内核的deb文件。

java -jar getKernel.jar v4.19.13

java程序getkernel.jar先通过命令行参数获得版本。

将版本拼接成网址https://kernel.ubuntu.com/~kernel-ppa/mainline/v4.19.13/

从网址读取网页，HttpURLConnection

并从中解析deb的超链接，java.util.regex.Pattern、Matcher

在把amd64的所有包都保存成文件。　　

估计用脚本调用wget可能更快。

贴代码

App.java

 package getKernel;

 import java.io.BufferedReader;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.net.HttpURLConnection;
 import java.net.URL;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 public class App {

     public static void main(String[] args) {
         String targetIndex = "https://kernel.ubuntu.com/~kernel-ppa/mainline/" + args[0] + "/";

         String strHeaderAll=null;
         String strHeaderAmd64=null;
         String strImageUnsignedAmd64=null;
         String strModulesAmd64=null;

         boolean foundHeaderAll = false;
         boolean foundHeaderAmd64 = false;
         boolean foundImageAmd64 = false;
         boolean foundModulesAmd64 = false;

         // 1 get file
         FileOutputStream fs = null;
         BufferedReader br = null;
         Pattern pattern = null;
         Matcher matcher = null;

         try {
             URL url = new URL(targetIndex);
             HttpURLConnection conn = (HttpURLConnection) url.openConnection();
             conn.connect();
             if (conn.getResponseCode() == 200) {
                 InputStream inStream = conn.getInputStream();
                 br = new BufferedReader(new InputStreamReader(inStream));
                 String str;
                 while ((str = br.readLine()) != null) {

                     if (!foundHeaderAll) {
                         pattern = Pattern.compile("href=\"(linux-headers-\\S+all.deb)\"", Pattern.CASE_INSENSITIVE);
                         matcher = pattern.matcher(str);
                         if (matcher.find()) {
                             strHeaderAll = targetIndex + matcher.group(1);
                             System.out.println(strHeaderAll);
                             foundHeaderAll = true;
                         }
                     }
                     if (!foundHeaderAmd64) {
                         pattern = Pattern.compile("href=\"(linux-headers-\\S+amd64.deb)\"", Pattern.CASE_INSENSITIVE);
                         matcher = pattern.matcher(str);
                         if (matcher.find()) {
                             strHeaderAmd64 = targetIndex + matcher.group(1);
                             System.out.println(strHeaderAmd64);
                             foundHeaderAmd64 = true;
                         }
                     }
                     if (!foundImageAmd64) {
                         pattern = Pattern.compile("href=\"(linux-image-unsigned\\S+amd64.deb)\"",
                                 Pattern.CASE_INSENSITIVE);
                         matcher = pattern.matcher(str);
                         if (matcher.find()) {
                             strImageUnsignedAmd64 = targetIndex + matcher.group(1);
                             System.out.println(strImageUnsignedAmd64);
                             foundImageAmd64 = true;
                         }

                     }
                     if (!foundModulesAmd64) {
                         pattern = Pattern.compile("href=\"(linux-modules\\S+amd64.deb)\"", Pattern.CASE_INSENSITIVE);
                         matcher = pattern.matcher(str);
                         if (matcher.find()) {
                             strModulesAmd64 = targetIndex + matcher.group(1);
                             System.out.println(strModulesAmd64);
                             foundModulesAmd64 = true;
                         }
                     }
                 }

                 SaveFile.saveUrl2file(strHeaderAll);
                 SaveFile.saveUrl2file(strHeaderAmd64);
                 SaveFile.saveUrl2file(strImageUnsignedAmd64);
                 SaveFile.saveUrl2file(strModulesAmd64);

             }

         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             if (br != null) {
                 try {
                     br.close();
                 } catch (IOException e1) {
                     e1.printStackTrace();
                 }
             }
             if (fs != null) {
                 try {
                     fs.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
     }

 }

SaveFile.java

 package getKernel;

 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.HttpURLConnection;
 import java.net.URL;

 public class SaveFile {

     public static void saveUrl2file(String strPath) {
         if (strPath == null)
             return;
         FileOutputStream fs = null;
         try {
             int bytesum = 0;
             int byteread = 0;

             URL url = new URL(strPath);
             HttpURLConnection conn = (HttpURLConnection) url.openConnection();
             conn.connect();
             if (conn.getResponseCode() == 200) {
                 InputStream inStream = conn.getInputStream();
                 int size = conn.getContentLength();
                 String filename = strPath.substring(strPath.lastIndexOf('/')+1, strPath.length());
                 System.out.println(filename);
                 fs = new FileOutputStream(filename);

                 byte[] buffer = new byte[1024*1024];
                 while ((byteread = inStream.read(buffer)) != -1) {
                     bytesum += byteread;
                     fs.write(buffer, 0, byteread);
                     String strPgs = "Progress:"+bytesum * 100 / size;
                     System.out.printf(strPgs);
                     for (int k = 0; k < strPgs.length(); k++)
                         System.out.print("\b");
                 }
             }

         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         } finally {

             if (fs != null) {
                 try {
                     fs.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
     }
 }

人生苦短，快用python

#!/usr/bin/env python
# coding: utf-8

import urllib.request
import threading
import re
import sys

patterns = [
    r'linux-headers-[_.\-\d]*all.deb',
    r'linux-headers-[_.\-\d]*\-generic[_.\-\d]*amd64.deb',
    r'linux-image-unsigned-[_.\-\d]*\-generic[_.\-\d]*amd64.deb',
    r'linux-modules-[_.\-\d]*\-generic[_.\-\d]*amd64.deb'
]

file_type = [
    'header-all',
    'header-generic-amd64',
    'image-unsigned-amd64',
    'modules-generic-amd64',
]

class Downloader(threading.Thread):
    def __init__(self, version, index_str, file_index):
        threading.Thread.__init__(self)
        self.file_index = file_index
        self.version = version
        try:
            print('Searching', file_type[self.file_index], 'URL.')
            self.file = re.search(
                patterns[self.file_index], index_str).group(0)
            self.url = 'https://kernel.ubuntu.com/~kernel-ppa/mainline/' + \
                self.version + '/' + self.file
            print('Found', self.url)
        except Exception as identifier:
            print('File Not Found!', file_type[self.file_index], identifier)

    def report_hook(self, count, block_size, total_size):
        new_progress = int(100.0 * count * block_size / total_size)
        print('{0}:{1},{2}%'.format(
            file_type[self.file_index], '['+str(count)+' / ' + str(int(total_size/block_size))+']', new_progress))

    def run(self):
        print('Start to download', self.file)
        try:
            urllib.request.urlretrieve(
                self.url, self.file, reporthook=self.report_hook)
        except Exception as identifier:
            print('Cannot download', self.file, identifier)

if __name__ == '__main__':
    if len(sys.argv) != 2:
        print('Please enter the kernel version.')
        sys.exit(-1)

    kernel_version = sys.argv[1]
    target_index = 'https://kernel.ubuntu.com/~kernel-ppa/mainline/' + kernel_version + '/'

    # get the file names and urls of the kernel files.
    try:
        index_str = ''
        print('Get', kernel_version, 'index from kernel.ubuntu.com.')
        with urllib.request.urlopen(target_index) as f:
            index_str = str(f.read())
        print('Got! Try to get kernel files for', kernel_version)
        threads = []
        for i in range(4):
            threads.append(Downloader(kernel_version, index_str, i))

        for t in threads:
            t.start()
        for t in threads:
            t.join()

        print('All files for', kernel_version, 'downloaded!')
    except Exception as e:
        print(e)