appfog-vmc-plugin 0.1.8 → 0.1.9

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZjhlY2VkZTAwMmY1NzA0OWMwYWEyMzg3Mjk4YzkyZTAwMmEzZTVkOA==
+    MzFlNWE1ZGY2M2RhYzE5YzhhMDQ0YzlmZTU1NTdhNDE3MjY5MTEzZg==
   data.tar.gz: !binary |-
-    ZWFlODc0OTkxMTBlNjM3NmExMTBjMDRiYjZmNzQ1ZTAxNzA0MmExNQ==
+    MGVhMzA0NTE3MzcxMjhiYjZiY2E0YTczYWEzNzZiZGU1ODY5ZjU2Ng==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    ZTEzZDAxYTUyOTNkMmNlYTY4MWQ4MWVkOWQ2Mjc0NmYzNmI4MWVjODVlOTA2
-    OTZiMjAyYTZhZTE2MjEwZDIxNjBhMWFhN2ZkZjM1MjNlODAyNmE4N2NiMWYw
-    ZGMzZjM3MDVmNDIyNzBiZTIwN2RlMmZjYjRjNGVmNWNhMGNmYzQ=
+    MmU1YmM0MWE0MGQ5YWEwMDIwZTczOTMyNWRmMTUxYWQ4YzVjYzdlM2IwZmE0
+    MTZjNjYwYmUyNTk2ODYxMGE4OTg4MjkzZDBmYTkxOWRjN2U0ZTc3OWY2YTI2
+    NjIyZmI1OTMxNzgzOGZmMThiYjIwODQ1MDk5ZDhjMDhlMmU4ZWI=
   data.tar.gz: !binary |-
-    OTFhNzExNmI3ZTVmYTg3YzA3NzAwMGVhZThjYWIwNDk0NWI4OTI4NTYwOWYz
-    M2JjNjM2ZjFkZWY0YzViYzc4YTgzNzJhYjg1NTg4YWViN2E1NWE1OTJiMTcz
-    MGMwMmVhM2Q1NDE1OWUyNzk5YmQ2NTUzZmVkMjk1ZGFiNTAwNzk=
+    Mzg3NDllNWE0ZjNhZTdmMzc1Y2QzOTBhMmY2NGEyMGEyYTU0NDE0ZDczNDE2
+    NWM2OGE2ZjgzYjQ0ODgxMjY0NWNkMTI5MTViNTc0ZTFkNzNiMTAwMTViMDZl
+    YTI3MTEzMGQ1MjBhODM2ZDUwNjYzOWNmMTAwMjM1MWMyNDhlOWE=

data/lib/appfog-vmc-plugin/cfoundry/upload_helpers.rb

@@ -7,7 +7,7 @@ module CFoundry
       elsif war_file = Dir.glob("#{path}/*.war").first
         CFoundry::Zip.unpack(war_file, to)
       else
-        check_unreachable_links(path)
+        #check_unreachable_links(path)
 
         FileUtils.mkdir(to)
 

data/lib/appfog-vmc-plugin/commands/pull.rb

@@ -9,6 +9,8 @@ module VMCAppfog
       app = input[:app]
       path = File.expand_path(input[:path] || app.name)
 
+      app = filter(:pull_app, app)
+
       with_progress("Pulling last pushed source code to #{c(app.name, :name)}") do
         client.app_pull(app.name, path)
       end

data/lib/appfog-vmc-plugin/plugin.rb

@@ -4,6 +4,8 @@ require "appfog-vmc-plugin/cfoundry"
 require "appfog-vmc-plugin/vmc"
 require "appfog-vmc-plugin/help"
 require "appfog-vmc-plugin/net_http"
+require "manifests-vmc-plugin/plugin"
+
 
 command_files = "../deprecated/**/*.rb"
 Dir[File.expand_path(command_files, __FILE__)].each do |file|

data/lib/appfog-vmc-plugin/version.rb

@@ -1,3 +1,3 @@
 module VMCAppfog
-  VERSION = "0.1.8".freeze
+  VERSION = "0.1.9".freeze
 end

data/lib/appfog-vmc-plugin/vmc/app/instances.rb

@@ -17,7 +17,7 @@ module VMC::App
         inst = input[:inst, app.total_instances]
       end
 
-      app.total_instances = inst if input.has?(:inst)
+      app.total_instances = inst.to_i if input.has?(:inst)
       fail "No changes!" unless app.changed?
 
       with_progress("Scaling #{c(app.name, :name)}") do

data/lib/manifests-vmc-plugin/errors.rb

@@ -0,0 +1,21 @@
+module VMCManifests
+  class CircularDependency < RuntimeError
+    def initialize(app)
+      @app = app
+    end
+
+    def to_s
+      "Circular dependency in application '#@app'"
+    end
+  end
+
+  class UnknownSymbol < RuntimeError
+    def initialize(sym)
+      @sym = sym
+    end
+
+    def to_s
+      "Undefined symbol in manifest: '#@sym'"
+    end
+  end
+end

data/lib/manifests-vmc-plugin/loader/builder.rb

@@ -0,0 +1,34 @@
+module VMCManifests
+  module Builder
+    # parse a manifest and merge with its inherited manifests
+    def build(file)
+      manifest = YAML.load_file file
+
+      Array(manifest["inherit"]).each do |path|
+        manifest = merge_parent(path, manifest)
+      end
+
+      manifest
+    end
+
+    private
+
+    # merge the manifest at `parent_path' into the `child'
+    def merge_parent(parent_path, child)
+      merge_manifest(build(from_manifest(parent_path)), child)
+    end
+
+    # deep hash merge
+    def merge_manifest(parent, child)
+      merge = proc do |_, old, new|
+        if new.is_a?(Hash) && old.is_a?(Hash)
+          old.merge(new, &merge)
+        else
+          new
+        end
+      end
+
+      parent.merge(child, &merge)
+    end
+  end
+end

data/lib/manifests-vmc-plugin/loader/normalizer.rb

@@ -0,0 +1,141 @@
+module VMCManifests
+  module Normalizer
+    MANIFEST_META = ["applications", "properties"]
+
+    def normalize!(manifest)
+      toplevel = toplevel_attributes(manifest)
+
+      apps = manifest["applications"]
+      apps ||= [{}]
+
+      default_paths_to_keys!(apps)
+
+      apps = convert_to_array(apps)
+
+      merge_toplevel!(toplevel, manifest, apps)
+      normalize_apps!(apps)
+
+      manifest["applications"] = apps
+
+      normalize_paths!(apps)
+
+      keyval = normalize_key_val(manifest)
+      manifest.clear.merge!(keyval)
+
+      nil
+    end
+
+    private
+
+    def normalize_paths!(apps)
+      apps.each do |app|
+        app["path"] = from_manifest(app["path"])
+      end
+    end
+
+    def convert_to_array(apps)
+      return apps if apps.is_a?(Array)
+
+      ordered_by_deps(apps)
+    end
+
+    # sort applications in dependency order
+    # e.g. if A depends on B, B will be listed before A
+    def ordered_by_deps(apps, processed = Set[])
+      ordered = []
+      apps.each do |tag, info|
+        next if processed.include?(tag)
+
+        if deps = Array(info["depends-on"])
+          dep_apps = {}
+          deps.each do |dep|
+            dep_apps[dep] = apps[dep]
+          end
+
+          processed.add(tag)
+
+          ordered += ordered_by_deps(dep_apps, processed)
+          ordered << info
+        else
+          ordered << info
+          processed.add(tag)
+        end
+      end
+
+      ordered.each { |app| app.delete("depends-on") }
+
+      ordered
+    end
+
+    def default_paths_to_keys!(apps)
+      return if apps.is_a?(Array)
+
+      apps.each do |tag, app|
+        app["path"] ||= tag
+      end
+    end
+
+    def normalize_apps!(apps)
+      apps.each do |app|
+        normalize_app!(app)
+      end
+    end
+
+    def merge_toplevel!(toplevel, manifest, apps)
+      return if toplevel.empty?
+
+      apps.collect! do |a|
+        toplevel.merge(a)
+      end
+
+      toplevel.each do |k, _|
+        manifest.delete k
+      end
+    end
+
+    def normalize_app!(app)
+      if app["framework"].is_a?(Hash)
+        app["framework"] = app["framework"]["name"]
+      end
+
+      if app.key?("mem")
+        app["memory"] = app.delete("mem")
+      end
+
+      if app.key?("url") && app["url"].nil?
+        app["url"] = "none"
+      end
+    end
+
+    def toplevel_attributes(manifest)
+      top =
+        manifest.reject { |k, _|
+          MANIFEST_META.include? k
+        }
+
+      # implicit toplevel path of .
+      top["path"] ||= "."
+
+      top
+    end
+
+    def normalize_key_val(val)
+      case val
+      when Hash
+        stringified = {}
+
+        val.each do |k, v|
+          stringified[k.to_sym] = normalize_key_val(v)
+        end
+
+        stringified
+      when Array
+        val.collect { |x| normalize_key_val(x) }
+      when nil
+        nil
+      else
+        val.to_s
+      end
+    end
+  end
+end

data/lib/manifests-vmc-plugin/loader/resolver.rb

@@ -0,0 +1,79 @@
+module VMCManifests
+  module Resolver
+    def resolve(manifest, resolver)
+      new = {}
+
+      new[:applications] = manifest[:applications].collect do |app|
+        resolve_lexically(resolver, app, [manifest])
+      end
+
+      resolve_lexically(resolver, new, [new])
+    end
+
+    private
+
+    # resolve symbols, with hashes introducing new lexical symbols
+    def resolve_lexically(resolver, val, ctx)
+      case val
+      when Hash
+        new = {}
+
+        val.each do |k, v|
+          new[k] = resolve_lexically(resolver, v, [val] + ctx)
+        end
+
+        new
+      when Array
+        val.collect do |v|
+          resolve_lexically(resolver, v, ctx)
+        end
+      when String
+        val.gsub(/\$\{([^\}]+)\}/) do
+          resolve_symbol(resolver, $1, ctx)
+        end
+      else
+        val
+      end
+    end
+
+    # resolve a symbol to its value, and then resolve that value
+    def resolve_symbol(resolver, sym, ctx)
+      if found = find_symbol(sym.to_sym, ctx)
+        resolve_lexically(resolver, found, ctx)
+        found
+      elsif dynamic = resolver.resolve_symbol(sym)
+        dynamic
+      else
+        fail("Unknown symbol in manifest: #{sym}")
+      end
+    end
+
+    # search for a symbol introduced in the lexical context
+    def find_symbol(sym, ctx)
+      ctx.each do |h|
+        if val = resolve_in(h, sym)
+          return val
+        end
+      end
+
+      nil
+    end
+
+    # find a value, searching in explicit properties first
+    def resolve_in(hash, *where)
+      find_in_hash(hash, [:properties] + where) ||
+        find_in_hash(hash, where)
+    end
+
+    # helper for following a path of values in a hash
+    def find_in_hash(hash, where)
+      what = hash
+      where.each do |x|
+        return nil unless what.is_a?(Hash)
+        what = what[x]
+      end
+
+      what
+    end
+  end
+end

data/lib/manifests-vmc-plugin/loader.rb

@@ -0,0 +1,31 @@
+require "manifests-vmc-plugin/loader/builder"
+require "manifests-vmc-plugin/loader/normalizer"
+require "manifests-vmc-plugin/loader/resolver"
+
+module VMCManifests
+  class Loader
+    include Builder
+    include Normalizer
+    include Resolver
+
+    def initialize(file, resolver)
+      @file = file
+      @resolver = resolver
+    end
+
+    def manifest
+      info = build(@file)
+      normalize! info
+      resolve info, @resolver
+    end
+
+    private
+
+    # expand a path relative to the manifest file's directory
+    def from_manifest(path)
+      return path unless @file
+
+      File.expand_path(path, File.dirname(@file))
+    end
+  end
+end

data/lib/manifests-vmc-plugin/manifests.rb

@@ -0,0 +1,315 @@
+require "yaml"
+require "set"
+
+require "manifests-vmc-plugin/loader"
+
+
+module VMCManifests
+  MANIFEST_FILE = "manifest.yml"
+
+  @@showed_manifest_usage = false
+
+  def manifest
+    return @manifest if @manifest
+
+    if manifest_file && File.exists?(manifest_file)
+      @manifest = load_manifest(manifest_file)
+    end
+  end
+
+  def save_manifest(save_to = manifest_file)
+    fail "No manifest to save!" unless @manifest
+
+    File.open(save_to, "w") do |io|
+      YAML.dump(@manifest, io)
+    end
+  end
+
+  # find the manifest file to work with
+  def manifest_file
+    return @manifest_file if @manifest_file
+
+    unless path = input[:manifest]
+      where = Dir.pwd
+      while true
+        if File.exists?(File.join(where, MANIFEST_FILE))
+          path = File.join(where, MANIFEST_FILE)
+          break
+        elsif File.basename(where) == "/"
+          path = nil
+          break
+        else
+          where = File.expand_path("../", where)
+        end
+      end
+    end
+
+    return unless path
+
+    @manifest_file = File.expand_path(path)
+  end
+
+  # load and resolve a given manifest file
+  def load_manifest(file)
+    Loader.new(file, self).manifest
+  end
+
+  # dynamic symbol resolution
+  def resolve_symbol(sym)
+    case sym
+    when "target-url"
+      client_target
+
+    when "target-base"
+      target_base
+
+    when "random-word"
+      sprintf("%04x", rand(0x0100000))
+
+    when /^ask (.+)/
+      ask($1)
+    end
+  end
+
+  # find apps by an identifier, which may be either a tag, a name, or a path
+  def find_apps(identifier)
+    return [] unless manifest
+
+    apps = apps_by(:name, identifier)
+
+    if apps.empty?
+      apps = apps_by(:path, from_manifest(identifier))
+    end
+
+    apps
+  end
+
+  # return all the apps described by the manifest
+  def all_apps
+    manifest[:applications]
+  end
+
+  def current_apps
+    manifest[:applications].select do |app|
+      next unless app[:path]
+      from_manifest(app[:path]) == Dir.pwd
+    end
+  end
+
+  # splits the user's input, resolving paths with the manifest,
+  # into internal/external apps
+  #
+  # internal apps are returned as their data in the manifest
+  #
+  # external apps are the strings that the user gave, to be
+  # passed along wholesale to the wrapped command
+  def apps_in_manifest(input = nil, use_name = true, &blk)
+    names_or_paths =
+      if input.has?(:apps)
+        # names may be given but be [], which will still cause
+        # interaction, so use #direct instead of #[] here
+        input.direct(:apps)
+      elsif input.has?(:app)
+        [input.direct(:app)]
+      elsif input.has?(:name)
+        [input.direct(:name)]
+      else
+        []
+      end
+
+    internal = []
+    external = []
+
+    names_or_paths.each do |x|
+      if x.is_a?(String)
+        if x =~ %r([/\\])
+          apps = find_apps(File.expand_path(x))
+
+          if apps.empty?
+            fail("Path #{b(x)} is not present in manifest #{b(relative_manifest_file)}.")
+          end
+        else
+          apps = find_apps(x)
+        end
+
+        if !apps.empty?
+          internal += apps
+        else
+          external << x
+        end
+      else
+        external << x
+      end
+    end
+
+    [internal, external]
+  end
+
+  def create_manifest_for(app, path)
+    meta = {
+      "name" => app.name,
+      "infra" => app.infra.name,
+      "framework" => app.framework.name,
+      "runtime" => app.runtime.name,
+      "memory" => human_size(app.memory * 1024 * 1024, 0),
+      "instances" => app.total_instances,
+      "url" => app.url ? app.url.sub(target_base, '${target-base}') : "none",
+      "path" => path
+    }
+
+    services = app.services
+
+    unless services.empty?
+      meta["services"] = {}
+
+      services.each do |i|
+        if v2?
+          p = i.service_plan
+          s = p.service
+
+          meta["services"][i.name] = {
+            "label" => s.label,
+            "provider" => s.provider,
+            "version" => s.version,
+            "plan" => p.name
+          }
+        else
+          meta["services"][i.name] = {
+            "infra" => i.infra.name,
+            "vendor" => i.vendor,
+            "version" => i.version,
+            "tier" => i.tier
+          }
+        end
+      end
+    end
+
+    if cmd = app.command
+      meta["command"] = cmd
+    end
+
+    meta
+  end
+
+  private
+
+  def relative_manifest_file
+    Pathname.new(manifest_file).relative_path_from(Pathname.pwd)
+  end
+
+  def show_manifest_usage
+    return if @@showed_manifest_usage
+
+    path = relative_manifest_file
+    line "Using manifest file #{c(path, :name)}"
+    line
+
+    @@showed_manifest_usage = true
+  end
+
+  def no_apps
+    fail "No applications or manifest to operate on."
+  end
+
+  def warn_reset_changes
+    line c("Not applying manifest changes without --reset", :warning)
+    line "See `vmc diff` for more details."
+    line
+  end
+
+  def apps_by(attr, val)
+    manifest[:applications].select do |info|
+      info[attr] == val
+    end
+  end
+
+  # expand a path relative to the manifest file's directory
+  def from_manifest(path)
+    File.expand_path(path, File.dirname(manifest_file))
+  end
+
+
+  def ask_to_save(input, app)
+    return if manifest_file
+    return unless ask("Save configuration?", :default => false)
+
+    manifest = create_manifest_for(app, input[:path])
+
+    with_progress("Saving to #{c("manifest.yml", :name)}") do
+      File.open("manifest.yml", "w") do |io|
+        YAML.dump(
+          { "applications" => [manifest] },
+          io)
+      end
+    end
+  end
+
+  def env_hash(val)
+    if val.is_a?(Hash)
+      val
+    else
+      hash = {}
+
+      val.each do |pair|
+        name, val = pair.split("=", 2)
+        hash[name] = val
+      end
+
+      hash
+    end
+  end
+
+  def setup_env(app, info)
+    return unless info[:env]
+    app.env = env_hash(info[:env])
+  end
+
+  def setup_services(app, info)
+    return if !info[:services] || info[:services].empty?
+
+    offerings = client.services
+
+    to_bind = []
+
+    info[:services].each do |name, svc|
+      name = name.to_s
+
+      if instance = client.service_instance_by_name(name)
+        to_bind << instance
+      else
+        offering = offerings.find { |o|
+          o.label == (svc[:label] || svc[:type] || svc[:vendor]) &&
+            (!svc[:version] || o.version == svc[:version]) &&
+            (o.provider == (svc[:provider] || "core"))
+        }
+
+        fail "Unknown service offering: #{svc.inspect}." unless offering
+
+        if v2?
+          plan = offering.service_plans.find { |p|
+            p.name == (svc[:plan] || "D100")
+          }
+
+          fail "Unknown service plan: #{svc[:plan]}." unless plan
+        end
+
+        invoke :create_service,
+          :name => name,
+          :offering => offering,
+          :plan => plan,
+          :app => app
+      end
+    end
+
+    to_bind.each do |s|
+      next if app.binds?(s)
+
+      # TODO: splat
+      invoke :bind_service, :app => app, :service => s
+    end
+  end
+
+  def target_base
+    client_target.sub(/^[^\.]+\./, "")
+  end
+end

data/lib/manifests-vmc-plugin/plugin.rb

@@ -0,0 +1,149 @@
+require "pathname"
+
+require "vmc/plugin"
+require "manifests-vmc-plugin/manifests"
+
+
+class ManifestsPlugin < VMC::App::Base
+  include VMCManifests
+
+  option :manifest, :aliases => "-m", :value => :file,
+    :desc => "Path to manifest file to use"
+
+
+  [ :start, :restart, :instances, :logs, :env, :health, :stats,
+    :scale, :app, :stop, :delete
+  ].each do |wrap|
+    name_made_optional = change_argument(wrap, :app, :optional)
+
+    around(wrap) do |cmd, input|
+      wrap_with_optional_name(name_made_optional, cmd, input)
+    end
+  end
+
+
+  add_input :push, :reset, :desc => "Reset to values in the manifest",
+            :default => false
+
+  around(:push) do |push, input|
+    wrap_push(push, input)
+  end
+
+  # around(:pull) do |push, input|
+  #   wrap_push(push, input)
+  # end
+
+  private
+
+  def wrap_with_optional_name(name_made_optional, cmd, input)
+    return cmd.call if input[:all]
+
+    unless manifest
+      # if the command knows how to handle this
+      if input.has?(:app) || !name_made_optional
+        return cmd.call
+      else
+        return no_apps
+      end
+    end
+
+    internal, external = apps_in_manifest(input)
+
+    return cmd.call if internal.empty? && !external.empty?
+
+    show_manifest_usage
+
+    if internal.empty? && external.empty?
+      internal = current_apps if internal.empty?
+      internal = all_apps if internal.empty?
+    end
+
+    internal = internal.collect { |app| app[:name] }
+
+    apps = internal + external
+    return no_apps if apps.empty?
+
+    apps.each.with_index do |app, num|
+      line unless quiet? || num == 0
+      cmd.call(input.without(:apps).merge_given(:app => app))
+    end
+  end
+
+  def apply_changes(app, input)
+    app.memory = megabytes(input[:memory]) if input.has?(:memory)
+    app.total_instances = input[:instances] if input.has?(:instances)
+    app.command = input[:command] if input.has?(:command)
+    app.production = input[:plan].upcase.start_with?("P") if input.has?(:plan)
+    app.infra = input[:infra] if input.has?(:infra)
+    app.framework = input[:framework] if input.has?(:framework)
+    app.runtime = input[:runtime] if input.has?(:runtime)
+    app.buildpack = input[:buildpack] if input.has?(:buildpack)
+  end
+
+  def wrap_push(push, input)
+    unless manifest
+      create_and_save_manifest(push, input)
+      return
+    end
+
+    particular, external = apps_in_manifest(input)
+
+    unless external.empty?
+      fail "Could not find #{b(external.join(", "))}' in the manifest."
+    end
+
+    apps = particular.empty? ? all_apps : particular
+
+    show_manifest_usage
+
+    spaced(apps) do |app_manifest|
+      push_with_manifest(app_manifest, push, input)
+    end
+  end
+
+  def push_with_manifest(app_manifest, push, input)
+    with_filters(
+      :push => {
+        :create_app => proc { |a|
+          setup_env(a, app_manifest)
+          a
+        },
+        :push_app => proc { |a|
+          setup_services(a, app_manifest)
+          a
+        }
+      }) do
+      app_input = push_input_for(app_manifest, input)
+
+      push.call(app_input)
+    end
+  end
+
+  def push_input_for(app_manifest, input)
+    existing_app = client.app_by_name(app_manifest[:name])
+
+    if !existing_app || input[:reset]
+      input = input.rebase_given(app_manifest)
+    else
+      warn_reset_changes if manifest_differs?(existing_app, input)
+    end
+
+    input.merge(
+      :path => from_manifest(app_manifest[:path]),
+      :name => app_manifest[:name],
+      :bind_services => false,
+      :create_services => false)
+  end
+
+  def manifest_differs?(app, input)
+    apply_changes(app, input)
+    app.changed?
+  end
+
+  def create_and_save_manifest(push, input)
+    with_filters(
+        :push => { :push_app => proc { |a| ask_to_save(input, a); a } }) do
+      push.call
+    end
+  end
+end

data/lib/manifests-vmc-plugin/version.rb

@@ -0,0 +1,3 @@
+module VMCManifests
+  VERSION = "0.6.1".freeze
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: appfog-vmc-plugin
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Tim Santeford
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-20 00:00:00.000000000 Z
+date: 2013-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cfoundry
@@ -65,6 +65,14 @@ files:
 - lib/appfog-vmc-plugin/vmc/start/login.rb
 - lib/appfog-vmc-plugin/vmc/user/base.rb
 - lib/appfog-vmc-plugin/vmc.rb
+- lib/manifests-vmc-plugin/errors.rb
+- lib/manifests-vmc-plugin/loader/builder.rb
+- lib/manifests-vmc-plugin/loader/normalizer.rb
+- lib/manifests-vmc-plugin/loader/resolver.rb
+- lib/manifests-vmc-plugin/loader.rb
+- lib/manifests-vmc-plugin/manifests.rb
+- lib/manifests-vmc-plugin/plugin.rb
+- lib/manifests-vmc-plugin/version.rb
 homepage: http://www.appfog.com/
 licenses: []
 metadata: {}