add proper GitRepoStep

.github/workflows/artifact.yml

@@ -13,13 +13,7 @@ jobs:
         with:
           version: 0.9.0-dev.927+eb5e4ac49
       - run: |
-          git clone https://github.com/marler8997/ziget ./dep/ziget
-          git -C ./dep/ziget checkout $(cat zigetsha) -b for_zigup
-          git clone https://github.com/marler8997/iguanaTLS ./dep/iguanaTLS
-          git -C ./dep/iguanaTLS checkout $(cat ziget-build-files-copy/iguanasha) -b for_ziget
-          git clone https://github.com/SuperAuguste/zarc ./dep/zarc
-          git -C ./dep/zarc checkout $(cat zarcsha) -b for_zigup
-          zig build test -Diguana -Dcpu=baseline
+          zig build test -Dfetch -Diguana -Dcpu=baseline
         shell: bash
       - uses: actions/upload-artifact@v2
         with:

build.zig

@@ -3,6 +3,8 @@ const builtin = @import("builtin");
 const Builder = std.build.Builder;
 const Pkg = std.build.Pkg;
 
+const GitRepoStep = @import("ziget-build-files-copy/GitRepoStep.zig");
+
 const zigetbuild = @import("ziget-build-files-copy/build.zig");
 // TODO: use this if/when we get @tryImport
 //const SslBackend = if (zigetbuild) zigetbuild.SslBackend else enum {};
@@ -14,11 +16,11 @@ fn unwrapOptionalBool(optionalBool: ?bool) bool {
 }
 
 pub fn build(b: *Builder) !void {
-    const ziget_repo = try (GitRepo {
+    const ziget_repo = GitRepoStep.create(b, .{
         .url = "https://github.com/marler8997/ziget",
         .branch = null,
-        .sha = @embedFile("zigetsha"),
-    }).resolve(b.allocator);
+        .sha = "4ae949f2e1ae701a3c16e9cc1aeb0355fea4cffd",
+    });
 
     // TODO: implement this if/when we get @tryImport
     //if (zigetbuild) |_| { } else {
@@ -61,7 +63,13 @@ fn addTest(b: *Builder, exe: *std.build.LibExeObjStep, target: std.zig.CrossTarg
     test_step.dependOn(&run_cmd.step);
 }
 
-fn addZigupExe(b: *Builder, ziget_repo: []const u8, target: std.zig.CrossTarget, mode: std.builtin.Mode, ssl_backend: ?SslBackend) !*std.build.LibExeObjStep {
+fn addZigupExe(
+    b: *Builder,
+    ziget_repo: *GitRepoStep,
+    target: std.zig.CrossTarget,
+    mode: std.builtin.Mode,
+    ssl_backend: ?SslBackend
+) !*std.build.LibExeObjStep {
     const require_ssl_backend = b.allocator.create(RequireSslBackendStep) catch unreachable;
     require_ssl_backend.* = RequireSslBackendStep.init(b, "the zigup exe", ssl_backend);
 
@@ -71,7 +79,7 @@ fn addZigupExe(b: *Builder, ziget_repo: []const u8, target: std.zig.CrossTarget,
 
     const ziget_ssl_pkg = blk: {
         if (ssl_backend) |backend| {
-            break :blk zigetbuild.addSslBackend(exe, backend, ziget_repo) catch {
+            break :blk zigetbuild.addSslBackend(exe, backend, ziget_repo.path) catch {
                 const ssl_backend_failed = b.allocator.create(SslBackendFailedStep) catch unreachable;
                 ssl_backend_failed.* = SslBackendFailedStep.init(b, "the zigup exe", backend);
                 break :blk Pkg {
@@ -85,21 +93,27 @@ fn addZigupExe(b: *Builder, ziget_repo: []const u8, target: std.zig.CrossTarget,
             .path = .{ .path = "no-ssl-backend-configured.zig" },
         };
     };
-    exe.addPackage(Pkg {
-        .name = "ziget",
-        .path = .{ .path = try join(b, &[_][]const u8 { ziget_repo, "ziget.zig" }) },
-        .dependencies = &[_]Pkg {ziget_ssl_pkg},
-    });
+    exe.step.dependOn(&ziget_repo.step);
+    {
+        const ziget_repo_path = ziget_repo.getPath(&exe.step);
+        exe.addPackage(Pkg {
+            .name = "ziget",
+            .path = .{ .path = try join(b, &[_][]const u8 { ziget_repo_path, "ziget.zig" }) },
+            .dependencies = &[_]Pkg {ziget_ssl_pkg},
+        });
+    }
 
     if (targetIsWindows(target)) {
-        const zarc_repo = try (GitRepo {
+        const zarc_repo = GitRepoStep.create(b, .{
             .url = "https://github.com/SuperAuguste/zarc",
             .branch = null,
-            .sha = @embedFile("zarcsha"),
-        }).resolve(b.allocator);
+            .sha = "accc35c0bf190d55133cc689cf989c03bf853349",
+        });
+        exe.step.dependOn(&zarc_repo.step);
+        const zarc_repo_path = zarc_repo.getPath(&exe.step);
         exe.addPackage(Pkg {
             .name = "zarc",
-            .path = .{ .path = try join(b, &[_][]const u8 { zarc_repo, "src", "main.zig" }) },
+            .path = .{ .path = try join(b, &[_][]const u8 { zarc_repo_path, "src", "main.zig" }) },
         });
     }
 
@@ -171,51 +185,3 @@ fn addGithubReleaseExe(b: *Builder, github_release_step: *std.build.Step, ziget_
 fn join(b: *Builder, parts: []const []const u8) ![]const u8 {
     return try std.fs.path.join(b.allocator, parts);
 }
-
-pub const GitRepo = struct {
-    url: []const u8,
-    branch: ?[]const u8,
-    sha: []const u8,
-    path: ?[]const u8 = null,
-
-    pub fn defaultReposDir(allocator: *std.mem.Allocator) ![]const u8 {
-        const cwd = try std.process.getCwdAlloc(allocator);
-        defer allocator.free(cwd);
-        return try std.fs.path.join(allocator, &[_][]const u8 { cwd, "dep" });
-    }
-
-    pub fn resolve(self: GitRepo, allocator: *std.mem.Allocator) ![]const u8 {
-        var optional_repos_dir_to_clean: ?[]const u8 = null;
-        defer {
-            if (optional_repos_dir_to_clean) |p| {
-                allocator.free(p);
-            }
-        }
-
-        const path = if (self.path) |p| try allocator.dupe(u8, p) else blk: {
-            const repos_dir = try defaultReposDir(allocator);
-            optional_repos_dir_to_clean = repos_dir;
-            break :blk try std.fs.path.join(allocator, &[_][]const u8{ repos_dir, std.fs.path.basename(self.url) });
-        };
-        errdefer self.allocator.free(path);
-
-        std.fs.accessAbsolute(path, std.fs.File.OpenFlags { .read = true }) catch {
-            std.debug.print("Error: repository '{s}' does not exist\n", .{path});
-            std.debug.print("       Run the following to clone it:\n", .{});
-            const branch_args = if (self.branch) |b| &[2][]const u8 {" -b ", b} else &[2][]const u8 {"", ""};
-            std.debug.print("       git clone {s}{s}{s} {s} && git -C {3s} checkout {s} -b for_zigup\n",
-                .{self.url, branch_args[0], branch_args[1], path, self.sha});
-            std.os.exit(1);
-        };
-
-        // TODO: check if the SHA matches an print a message and/or warning if it is different
-
-        return path;
-    }
-
-    pub fn resolveOneFile(self: GitRepo, allocator: *std.mem.Allocator, index_sub_path: []const u8) ![]const u8 {
-        const repo_path = try self.resolve(allocator);
-        defer allocator.free(repo_path);
-        return try std.fs.path.join(allocator, &[_][]const u8 { repo_path, index_sub_path });
-    }
-};

update-ziget-build-files-copy

@@ -13,7 +13,7 @@ fi
 
 rm -rf ziget-build-files-copy
 
-for f in build.zig iguanasha openssl/sources; do
+for f in build.zig GitRepoStep.zig openssl/sources; do
     dir=$(dirname $f)
     mkdir -p ziget-build-files-copy/$dir
     cp dep/ziget/$f ziget-build-files-copy/$dir

zarcsha

@@ -1 +0,0 @@
-accc35c0bf190d55133cc689cf989c03bf853349

ziget-build-files-copy/GitRepoStep.zig

@@ -0,0 +1,204 @@
+const std = @import("std");
+const GitRepoStep = @This();
+
+pub const ShaCheck = enum {
+    none,
+    warn,
+    err,
+
+    pub fn reportFail(self: ShaCheck, comptime fmt: []const u8, args: anytype) void {
+        switch (self) {
+            .none => unreachable,
+            .warn => std.log.warn(fmt, args),
+            .err => {
+                std.log.err(fmt, args);
+                std.os.exit(0xff);
+            },
+        }
+    }
+};
+
+step: std.build.Step,
+builder: *std.build.Builder,
+url: []const u8,
+name: []const u8,
+branch: ?[]const u8 = null,
+sha: []const u8,
+path: []const u8 = null,
+sha_check: ShaCheck = .warn,
+fetch_enabled: bool,
+
+var cached_default_fetch_option: ?bool = null;
+pub fn defaultFetchOption(b: *std.build.Builder) bool {
+    if (cached_default_fetch_option) |_| { } else {
+        cached_default_fetch_option = if (b.option(bool, "fetch", "automatically fetch network resources")) |o| o else false;
+    }
+    return cached_default_fetch_option.?;
+}
+
+pub fn create(b: *std.build.Builder, opt: struct {
+    url: []const u8,
+    branch: ?[]const u8 = null,
+    sha: []const u8,
+    path: ?[]const u8 = null,
+    sha_check: ShaCheck = .warn,
+    fetch_enabled: ?bool = null,
+}) *GitRepoStep {
+    var result = b.allocator.create(GitRepoStep) catch @panic("memory");
+    const name = std.fs.path.basename(opt.url);
+    result.* = GitRepoStep {
+        .step = std.build.Step.init(.custom, "clone a git repository", b.allocator, make),
+        .builder = b,
+        .url = opt.url,
+        .name = name,
+        .branch = opt.branch,
+        .sha = opt.sha,
+        .path = if (opt.path) |p| (b.allocator.dupe(u8, p) catch @panic("memory")) else (
+            std.fs.path.resolve(b.allocator, &[_][]const u8{
+                b.build_root,
+                "dep", 
+                name,
+            })
+        ) catch @panic("memory"),
+        .sha_check = opt.sha_check,
+        .fetch_enabled = if (opt.fetch_enabled) |fe| fe else defaultFetchOption(b),
+    };
+    return result;
+}
+
+// TODO: this should be included in std.build, it helps find bugs in build files
+fn hasDependency(step: *const std.build.Step, dep_candidate: *const std.build.Step) bool {
+    for (step.dependencies.items) |dep| {
+         // TODO: should probably use step.loop_flag to prevent infinite recursion
+        //       when a circular reference is encountered, or maybe keep track of
+        //       the steps encounterd with a hash set
+        if (dep == dep_candidate or hasDependency(dep, dep_candidate))
+            return true;
+    }
+    return false;
+}
+
+fn make(step: *std.build.Step) !void {
+    const self = @fieldParentPtr(GitRepoStep, "step", step);
+
+    std.fs.accessAbsolute(self.path, std.fs.File.OpenFlags { .read = true }) catch {
+        const branch_args = if (self.branch) |b| &[2][]const u8 {" -b ", b} else &[2][]const u8 {"", ""};
+        if (!self.fetch_enabled) {
+            std.debug.print("Error: git repository '{s}' does not exist\n", .{self.path});
+            std.debug.print("       Use -Dfetch to download it automatically, or run the following to clone it:\n", .{});
+            std.debug.print("       git clone {s}{s}{s} {s} && git -C {3s} checkout {s} -b for_ziget\n",
+                .{self.url, branch_args[0], branch_args[1], self.path, self.sha});
+            std.os.exit(1);
+        }
+
+        {
+            var args = std.ArrayList([]const u8).init(self.builder.allocator);
+            defer args.deinit();
+            try args.append("git");
+            try args.append("clone");
+            try args.append(self.url);
+            // TODO: clone it to a temporary location in case of failure
+            //       also, remove that temporary location before running
+            try args.append(self.path);
+            if (self.branch) |branch| {
+                try args.append("-b");
+                try args.append(branch);
+            }
+            try run(self.builder, args.items);
+        }
+        try run(self.builder, &[_][]const u8 {
+            "git",
+            "-C", self.path,
+            "checkout",
+            self.sha,
+            "-b",
+            "fordep",
+        });
+    };
+
+    try self.checkSha();
+}
+
+fn checkSha(self: GitRepoStep) !void {
+    if (self.sha_check == .none)
+        return;
+
+    const result: union(enum) { failed: anyerror, output: []const u8 } = blk: {
+        const result = std.ChildProcess.exec(.{
+            .allocator = self.builder.allocator,
+            .argv = &[_][]const u8 {
+                "git",
+                "-C", self.path,
+                "rev-parse",
+                "HEAD",
+            },
+            .cwd = self.builder.build_root,
+            .env_map = self.builder.env_map,
+        }) catch |e| break :blk .{ .failed = e };
+        try std.io.getStdErr().writer().writeAll(result.stderr);
+        switch (result.term) {
+            .Exited => |code| {
+                if (code == 0) break :blk .{ .output = result.stdout };
+                break :blk .{ .failed = error.GitProcessNonZeroExit };
+            },
+            .Signal => break :blk .{ .failed = error.GitProcessFailedWithSignal },
+            .Stopped => break :blk .{ .failed = error.GitProcessWasStopped },
+            .Unknown => break :blk .{ .failed = error.GitProcessFailed },
+        }
+    };
+    switch (result) {
+        .failed => |err| {
+            return self.sha_check.reportFail("failed to retreive sha for repository '{s}': {s}", .{self.name, @errorName(err)});
+        },
+        .output => |output| {
+            if (!std.mem.eql(u8, std.mem.trimRight(u8, output, "\n\r"), self.sha)) {
+                return self.sha_check.reportFail("repository '{s}' sha does not match\nexpected: {s}\nactual  : {s}\n", .{self.name, self.sha, output});
+            }
+        },
+    }
+}
+
+fn run(builder: *std.build.Builder, argv: []const []const u8) !void {
+    {
+        var msg = std.ArrayList(u8).init(builder.allocator);
+        defer msg.deinit();
+        const writer = msg.writer();
+        var prefix: []const u8 = "";
+        for (argv) |arg| {
+            try writer.print("{s}\"{s}\"", .{prefix, arg});
+            prefix = " ";
+        }
+        std.log.info("[RUN] {s}", .{msg.items});
+    }
+
+
+    const child = try std.ChildProcess.init(argv, builder.allocator);
+    defer child.deinit();
+
+    child.stdin_behavior = .Ignore;
+    child.stdout_behavior = .Inherit;
+    child.stderr_behavior = .Inherit;
+    child.cwd = builder.build_root;
+    child.env_map = builder.env_map;
+
+    try child.spawn();
+    const result = try child.wait();
+    switch (result) {
+        .Exited => |code| if (code != 0) {
+            std.log.err("git clone failed with exit code {}", .{code});
+            std.os.exit(0xff);
+        },
+        else => {
+            std.log.err("git clone failed with: {}", .{result});
+            std.os.exit(0xff);
+        },
+    }
+}
+
+// Get's the repository path and also verifies that the step requesting the path
+// is dependent on this step.
+pub fn getPath(self: *const GitRepoStep, who_wants_to_know: *const std.build.Step) []const u8 {
+    if (!hasDependency(who_wants_to_know, &self.step))
+        @panic("a step called GitRepoStep.getPath but has not added it as a dependency");
+    return self.path;
+}

ziget-build-files-copy/build.zig

@@ -2,8 +2,12 @@ const std = @import("std");
 const builtin = @import("builtin");
 const Builder = std.build.Builder;
 const Pkg = std.build.Pkg;
+const GitRepoStep = @import("GitRepoStep.zig");
 
 pub fn build(b: *Builder) !void {
+    // ensure we always support -Dfetch regardless of backend
+    _ = GitRepoStep.defaultFetchOption(b);
+
     const optional_ssl_backend = getSslBackend(b);
 
     const target = b.standardTargetOptions(.{});
@@ -129,17 +133,18 @@ pub fn addSslBackend(step: *std.build.LibExeObjStep, backend: SslBackend, ziget_
             };
         },
         .opensslstatic => {
-            const openssl_repo = try (GitRepo {
+            const openssl_repo = GitRepoStep.create(step.builder, .{
                 .url = "https://github.com/openssl/openssl",
                 .branch = "OpenSSL_1_1_1j",
                 .sha = "52c587d60be67c337364b830dd3fdc15404a2f04",
-            }).resolve(b.allocator);
+            });
 
             // TODO: should we implement something to cache the configuration?
             //       can the configure output be in a different directory?
             {
                 const configure_openssl = std.build.RunStep.create(b, "configure openssl");
-                configure_openssl.cwd = openssl_repo;
+                configure_openssl.step.dependOn(&openssl_repo.step);
+                configure_openssl.cwd = openssl_repo.getPath(&configure_openssl.step);
                 configure_openssl.addArgs(&[_][]const u8 {
                     "./config",
                     // just a temporary path for now
@@ -174,7 +179,7 @@ pub fn addSslBackend(step: *std.build.LibExeObjStep, backend: SslBackend, ziget_
                     .expect_matches = &[_][]const u8 { "OpenSSL has been successfully configured" },
                 };
                 const make_openssl = std.build.RunStep.create(b, "configure openssl");
-                make_openssl.cwd = openssl_repo;
+                make_openssl.cwd = configure_openssl.cwd;
                 make_openssl.addArgs(&[_][]const u8 {
                     "make",
                     "include/openssl/opensslconf.h",
@@ -184,9 +189,13 @@ pub fn addSslBackend(step: *std.build.LibExeObjStep, backend: SslBackend, ziget_
                 make_openssl.step.dependOn(&configure_openssl.step);
                 step.step.dependOn(&make_openssl.step);
             }
-            step.addIncludeDir(openssl_repo);
-            step.addIncludeDir(try std.fs.path.join(b.allocator, &[_][]const u8 { openssl_repo, "include" }));
-            step.addIncludeDir(try std.fs.path.join(b.allocator, &[_][]const u8 { openssl_repo, "crypto", "modes" }));
+
+            const openssl_repo_path_for_step = openssl_repo.getPath(&step.step);
+            step.addIncludeDir(openssl_repo_path_for_step);
+            step.addIncludeDir(try std.fs.path.join(b.allocator, &[_][]const u8 {
+                openssl_repo_path_for_step, "include" }));
+            step.addIncludeDir(try std.fs.path.join(b.allocator, &[_][]const u8 {
+                openssl_repo_path_for_step, "crypto", "modes" }));
             const cflags = &[_][]const u8 {
                 "-Wall",
                 // TODO: is this the right way to do this? is it a config option?
@@ -199,7 +208,8 @@ pub fn addSslBackend(step: *std.build.LibExeObjStep, backend: SslBackend, ziget_
                 var source_lines = std.mem.split(u8, sources, "\n");
                 while (source_lines.next()) |src| {
                     if (src.len == 0 or src[0] == '#') continue;
-                    step.addCSourceFile(try std.fs.path.join(b.allocator, &[_][]const u8 { openssl_repo, src }), cflags);
+                    step.addCSourceFile(try std.fs.path.join(b.allocator, &[_][]const u8 {
+                        openssl_repo_path_for_step, src }), cflags);
                 }
             }
             step.linkLibC();
@@ -213,11 +223,14 @@ pub fn addSslBackend(step: *std.build.LibExeObjStep, backend: SslBackend, ziget_
             std.os.exit(1);
         },
         .iguana => {
-            const iguana_index_file = try (GitRepo {
+            const iguana_repo = GitRepoStep.create(b, .{
                 .url = "https://github.com/marler8997/iguanaTLS",
                 .branch = null,
-                .sha = @embedFile("iguanasha"),
-            }).resolveOneFile(b.allocator, "src" ++ std.fs.path.sep_str ++ "main.zig");
+                .sha = "c1106fa6ecac1d51e8148cd47a8a4b99bb307af8",
+            });
+            step.step.dependOn(&iguana_repo.step);
+            const iguana_repo_path = iguana_repo.getPath(&step.step);
+            const iguana_index_file = try std.fs.path.join(b.allocator, &[_][]const u8 {iguana_repo_path, "src", "main.zig"});
             var p = Pkg {
                 .name = "ssl",
                 .path = .{ .path = try std.fs.path.join(b.allocator, &[_][]const u8 { ziget_repo, "iguana", "ssl.zig" }) },
@@ -234,14 +247,17 @@ pub fn addSslBackend(step: *std.build.LibExeObjStep, backend: SslBackend, ziget_
                 //       I'll probably port this to Zig at some point
                 //       Once I do remove this build config
                 // NOTE: I tested using this commit: 7338760a4a2c6fb80c47b24a2abba32d5fc40635 tagged at version 0.1.42
-                const msspi_repo = try (GitRepo {
+                const msspi_repo = GitRepoStep.create(b, .{
                     .url = "https://github.com/deemru/msspi",
                     .branch = "0.1.42",
                     .sha = "7338760a4a2c6fb80c47b24a2abba32d5fc40635"
-                }).resolve(b.allocator);
-                const msspi_src_dir = try std.fs.path.join(b.allocator, &[_][]const u8 { msspi_repo, "src" });
+                });
+                step.step.dependOn(&msspi_repo.step);
+                const msspi_repo_path = msspi_repo.getPath(&step.step);
+
+                const msspi_src_dir = try std.fs.path.join(b.allocator, &[_][]const u8 { msspi_repo_path, "src" });
                 const msspi_main_cpp = try std.fs.path.join(b.allocator, &[_][]const u8 { msspi_src_dir, "msspi.cpp" });
-                const msspi_third_party_include = try std.fs.path.join(b.allocator, &[_][]const u8 { msspi_repo, "third_party", "cprocsp", "include" });
+                const msspi_third_party_include = try std.fs.path.join(b.allocator, &[_][]const u8 { msspi_repo_path, "third_party", "cprocsp", "include" });
                 step.addCSourceFile(msspi_main_cpp, &[_][]const u8 { });
                 step.addIncludeDir(msspi_src_dir);
                 step.addIncludeDir(msspi_third_party_include);
@@ -287,51 +303,3 @@ pub fn setupOpensslWindows(step: *std.build.LibExeObjStep) !void {
         );
     }
 }
-
-pub const GitRepo = struct {
-    url: []const u8,
-    branch: ?[]const u8,
-    sha: []const u8,
-    path: ?[]const u8 = null,
-
-    pub fn defaultReposDir(allocator: *std.mem.Allocator) ![]const u8 {
-        const cwd = try std.process.getCwdAlloc(allocator);
-        defer allocator.free(cwd);
-        return try std.fs.path.join(allocator, &[_][]const u8 { cwd, "dep" });
-    }
-
-    pub fn resolve(self: GitRepo, allocator: *std.mem.Allocator) ![]const u8 {
-        var optional_repos_dir_to_clean: ?[]const u8 = null;
-        defer {
-            if (optional_repos_dir_to_clean) |p| {
-                allocator.free(p);
-            }
-        }
-
-        const path = if (self.path) |p| try allocator.dupe(u8, p) else blk: {
-            const repos_dir = try defaultReposDir(allocator);
-            optional_repos_dir_to_clean = repos_dir;
-            break :blk try std.fs.path.join(allocator, &[_][]const u8{ repos_dir, std.fs.path.basename(self.url) });
-        };
-        errdefer allocator.free(path);
-
-        std.fs.accessAbsolute(path, std.fs.File.OpenFlags { .read = true }) catch {
-            std.debug.print("Error: repository '{s}' does not exist\n", .{path});
-            std.debug.print("       Run the following to clone it:\n", .{});
-            const branch_args = if (self.branch) |b| &[2][]const u8 {" -b ", b} else &[2][]const u8 {"", ""};
-            std.debug.print("       git clone {s}{s}{s} {s} && git -C {3s} checkout {s} -b for_ziget\n",
-                .{self.url, branch_args[0], branch_args[1], path, self.sha});
-            std.os.exit(1);
-        };
-
-        // TODO: check if the SHA matches an print a message and/or warning if it is different
-
-        return path;
-    }
-
-    pub fn resolveOneFile(self: GitRepo, allocator: *std.mem.Allocator, index_sub_path: []const u8) ![]const u8 {
-        const repo_path = try self.resolve(allocator);
-        defer allocator.free(repo_path);
-        return try std.fs.path.join(allocator, &[_][]const u8 { repo_path, index_sub_path });
-    }
-};

ziget-build-files-copy/iguanasha

@@ -1 +0,0 @@
-c1106fa6ecac1d51e8148cd47a8a4b99bb307af8

zigetsha

@@ -1 +0,0 @@
-5b6f0667c906e1c76b71317a599d9a3831d50661