pkgs/tools/admin/google-cloud-sdk/components.nix

   1 { stdenv
   2 , lib
   3 , google-cloud-sdk
   4 , system
   5 , snapshotPath
   6 , ...
   7 }:
   8
   9 let
  10   # Mapping from GCS component architecture names to Nix archictecture names
  11   arches = {
  12     x86 = "i686";
  13     x86_64 = "x86_64";
  14     arm = "aarch64";
  15   };
  16
  17   # Mapping from GCS component operating systems to Nix operating systems
  18   oses = {
  19     LINUX = "linux";
  20     MACOSX = "darwin";
  21     WINDOWS = "windows";
  22     CYGWIN = "cygwin";
  23   };
  24
  25   # Convert an archicecture + OS to a Nix platform
  26   toNixPlatform = arch: os:
  27     let
  28       arch' = arches.${arch} or (throw "unsupported architecture '${arch}'");
  29       os' = oses.${os} or (throw "unsupported OS '${os}'");
  30     in
  31     "${arch'}-${os'}";
  32
  33   # All architectures that are supported by GCS
  34   allArches = builtins.attrNames arches;
  35
  36   # A description of all available google-cloud-sdk components.
  37   # It's a JSON file with a list of components, along with some metadata
  38   snapshot = builtins.fromJSON (builtins.readFile snapshotPath);
  39
  40   # Generate a snapshot file for a single component.  It has the same format as
  41   # `snapshot`, but only contains a single component.  These files are
  42   # installed with google-cloud-sdk to let it know which components are
  43   # available.
  44   snapshotFromComponent =
  45     { component
  46     , revision
  47     , schema_version
  48     , version
  49     }:
  50     builtins.toJSON {
  51       components = [ component ];
  52       inherit revision schema_version version;
  53     };
  54
  55   # Generate a set of components from a JSON file describing these components
  56   componentsFromSnapshot =
  57     { components
  58     , revision
  59     , schema_version
  60     , version
  61     , ...
  62     }:
  63     lib.fix (
  64       self:
  65       builtins.listToAttrs (
  66         builtins.map
  67           (component: {
  68             name = component.id;
  69             value = componentFromSnapshot self { inherit component revision schema_version version; };
  70           })
  71           components
  72       )
  73     );
  74
  75   # Generate a single component from its snapshot, along with a set of
  76   # available dependencies to choose from.
  77   componentFromSnapshot =
  78     # Component derivations that can be used as dependencies
  79     components:
  80     # This component's snapshot
  81     { component
  82     , revision
  83     , schema_version
  84     , version
  85     } @ attrs:
  86     let
  87       baseUrl = builtins.dirOf schema_version.url;
  88       # Architectures supported by this component.  Defaults to all available
  89       # architectures.
  90       architectures = builtins.filter
  91         (arch: builtins.elem arch (builtins.attrNames arches))
  92         (lib.attrByPath [ "platform" "architectures" ] allArches component);
  93       # Operating systems supported by this component
  94       operating_systems = builtins.filter
  95         (os: builtins.elem os (builtins.attrNames oses))
  96         component.platform.operating_systems;
  97     in
  98     mkComponent
  99       {
 100         name = component.id;
 101         version = component.version.version_string;
 102         src =
 103           if lib.hasAttrByPath [ "data" "source" ] component
 104           then "${baseUrl}/${component.data.source}"
 105           else "";
 106         sha256 = lib.attrByPath [ "data" "checksum" ] "" component;
 107         dependencies = builtins.map (dep: builtins.getAttr dep components) component.dependencies;
 108         platforms =
 109           if component.platform == { }
 110           then lib.platforms.all
 111           else
 112             builtins.concatMap
 113               (arch: builtins.map (os: toNixPlatform arch os) operating_systems)
 114               architectures;
 115         snapshot = snapshotFromComponent attrs;
 116       };
 117
 118   # Filter out dependencies not supported by current system
 119   filterForSystem = builtins.filter (drv: builtins.elem system drv.meta.platforms);
 120
 121   # Make a google-cloud-sdk component
 122   mkComponent =
 123     { name
 124     , version
 125       # Source tarball, if any
 126     , src ? ""
 127       # Checksum for the source tarball, if there is a source
 128     , sha256 ? ""
 129       # Other components this one depends on
 130     , dependencies ? [ ]
 131       # Short text describing the component
 132     , description ? ""
 133       # Platforms supported
 134     , platforms ? lib.platforms.all
 135       # The snapshot corresponding to this component
 136     , snapshot
 137     }: stdenv.mkDerivation {
 138       inherit name version snapshot;
 139       src =
 140         if src != "" then
 141           builtins.fetchurl
 142             {
 143               url = src;
 144               inherit sha256;
 145             } else "";
 146       phases = [ "installPhase" "fixupPhase" ];
 147       installPhase = ''
 148         mkdir -p $out/google-cloud-sdk/.install
 149
 150         # If there is a source, unpack it
 151         if [ ! -z "$src" ]; then
 152           tar -xf $src -C $out/google-cloud-sdk/
 153
 154           # If the source has binaries, link them to `$out/bin`
 155           if [ -d "$out/google-cloud-sdk/bin" ]; then
 156             mkdir $out/bin
 157             find $out/google-cloud-sdk/bin/ -type f -exec ln -s {} $out/bin/ \;
 158           fi
 159         fi
 160
 161         # Write the snapshot file to the `.install` folder
 162         cp $snapshotPath $out/google-cloud-sdk/.install/${name}.snapshot.json
 163       '';
 164       passthru = {
 165         dependencies = filterForSystem dependencies;
 166       };
 167       passAsFile = [ "snapshot" ];
 168       meta = {
 169         inherit description platforms;
 170       };
 171     };
 172 in
 173 componentsFromSnapshot snapshot