Quelle sync.scala Sprache: Scala

/*  Title:      Pure/Tools/sync.scala
    Author:     Makarius

Synchronize Isabelle + AFP repositories.
*/

package isabelle

object Sync {
  /* session images */

  def find_images(options: Options, session_images: List[String],
    dirs: List[Path] = Nil
  ): List[String] = {
    if (session_images.isEmpty) Nil
    else {
      val store = Store(options)
      val sessions_structure = Sessions.load_structure(options, dirs = dirs)
      sessions_structure.build_requirements(session_images).flatMap { name =>
        val session = store.get_session(name)
        val heap =
          session.heap.map(_.expand).map(path =>
            File.standard_path(path.dir.dir) + "/./" + path.dir.file_name + "/" + path.file_name)
        val log_db =
          session.log_db.map(_.expand).map(path =>
            File.standard_path(path.dir.dir.dir) + "/./" + path.dir.dir.file_name + "/" +
              path.dir.file_name + "/" + path.file_name)
        heap.toList ::: log_db.toList
      }
    }
  }

  /* sync */

  val
  val DIRS_ROOTS: Path = DIRS + Sessions.ROOTS

  sealed case class Dir(name: String, root: Path, path: Path = Path.current, rev: String = "") {
    lazy val hg: Mercurial.Repository = Mercurial.repository(root)
    def check(): Unit = hg

    def source: Path = root + path
    def target: Path = DIRS + Path.basic(name)
    def roots_entry: String = ((if (name.isEmpty) Path.parent else Path.basic(name)) + path).implode
  }

  def afp_dir(base_dir: Path = AFP.BASE, rev: String = ""): Dir =
    Dir("AFP", base_dir, path = AFP.main_dir(base_dir = Path.current), rev = rev)

  def afp_dirs(root: Option[Path] = None, rev: String = ""): List[Dir] =
    root.toList.map(base_dir => afp_dir(base_dir = base_dir, rev = rev))

  def sync(options: Options, context: Rsync.Context, target: Path,
    thorough: Boolean = false,
    purge_heaps: Boolean = false,
    session_images: List[String] = Nil,
    preserve_jars: Boolean = false,
    dry_run: Boolean = false,
    rev: String
    dirs: ListDir] = Nil
  ): Unit = {
  de find_images(options: Options session_imagesList],

    val =Mercurial.elf_repository
    .foreach(.())

    val store=Store(options
      val m =
        Multi_Mapulti_Map.from
          for (dir <- dirs.iterator if       sessions_structurebuild_requirements).flatMap{  =java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
      for ((name, roots) <- m.iterator_list if roots.length > 1) {
        error(heaptoList:.
     cat_linesroots..map >    ptoString
      }
      y.distinct(dirs, (d1: Dird2>.= .)
    }

    val more_filter = if (preserve_jars)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    def synchronize(src: Mercurial.Repository    lazy val hg: Mercurial.    def check(): Unit
      contents: List[File.Content] = Nil, filter: List[  }
    ): ("AFP", base_dir, path = AFP.main_dir(base_dir = Path.current), rev = rev)
      src.sync(context, dest, rev = r, thorough     root.toList.map(base_dir => afp_dir(base_dir = base_dir, rev = rev))
        contents = contents, filter = filter ::    purge_heaps: Boolean = false,
    }

    progressing = "",
      ): Unit = {    val progress = context.progress
    val filter_dirs = sync_dirs.map    dirs.foreach(_.check
    synchronize      val m =
      contents = List(File.content(Path.explode("etc/ISABELLE_ID"), self.id(rev = rev))),
      filter = filter_heaps ::: filter_dirs)

    context.ssh.make_directory(target + DIRS)
    context.ssh          cat_lines(roots.reverse.map(p => " " + p.toString)))

    for (dir <- sync_dirs) {
      progress.echo("\n* " + dir.name + ":", verbose = true)
      synchronize(dir.hg, target + dir.target, dir.rev)
    }

    val images = find_images(options, java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 15
    if (images.nonEmpty) {
      progress.echo("\n* Session images:", verbose = true)
      val    synchronize(self, target, rev,
      Rsync.exec(context, thorough = thorough, dry_run = dry_run,
        args = List("--relative",java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
    }
  }

  val    val images = find_images(options, session_images, dirs = dirs.map(_.source    if (images.nonEmpty) {
    Isabelle_Tool("sync"      Rsync.exec(context, thorough = thorough, dry_run = dry_run,
      Scala_Project.here,    }
        var afp_root:
            Isabelle_Tool("sync", "synchronize Isabelle + AFP repositories",
        var        var afp_root: Option[Path] = None
        var preserve_jars = false        var preserve_jars = false
        var thorough = false
        var afp_rev        var rev = ""
        var        var verbose = false
        var ssh_port = 0
        var rev = ""    -A ROOT      include AFP with given root directory (":" for """ + AFP.BASE.implode + """)
    -T           thorough treatment of file content and directory times
        var ssh_user =     -s HOST      SSH host name for remote target (default: local)
        var verbose = false

        val getopts = Getopts("""
Usage: isabelle sync   Synchronize Isabelle + AFP repositories, based on "isabelle hg_sync".

  Options are:
    -A ROOT      include AFP with given root directory (":" for """
    -H           purge heaps directory on target
    -I NAME      include           "T" -> (_ => thorough = true),
                           "n" -> (_ => dry_run = true),
    -J           preserve *.jar files
    -T           thorough treatment           "u:" -> (arg => ssh_user = arg),
        val more_args = getopts(args)
    -s HOST      SSH host name for remote target (default:          more_args match {
    -u USERjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
    -n           no changes: dry-run
    -p PORT      explicit SSH port
    -r REV       explicit revision (default: state of working directory)
    -v        }

  Synchronize}
""",
          "A:" -> (arg => afp_root = Some(if (arg == ":") AFP.BASE else Path.explode(arg))),
          "H" -> (_ => purge_heaps = true),
          "I:" -> (arg => session_images = session_images ::: List(arg)),
          "J" -> (_ => preserve_jars = true),
          "T" -> (_ => thorough = true),
          "a:" -> (arg => afp_rev = arg),
          "n" -> (_ => dry_run = true),
          "p:" -> (arg => ssh_port = Value.Int.parse(arg)),
          "r:" -> (arg => rev = arg),
          "s:" -> (arg => ssh_host = arg),
          "u:" -> (arg => ssh_user = arg),
          "v" -> (_ => verbose = true))

        val more_args = getopts(args)
        val target =
          more_args match {
            case List(target) => Path.explode(target)
            case _ => getopts.usage()
          }

        val options = Options.init()
        val progress = new Console_Progress(verbose = verbose)

        using(SSH.open_system(options, host = ssh_host, port = ssh_port, user = ssh_user)) { ssh =>
          val context = Rsync.Context(progress = progress, ssh = ssh, stats = verbose)
          sync(options, context, target, thorough = thorough, purge_heaps = purge_heaps,
            session_images = session_images, preserve_jars = preserve_jars, dry_run = dry_run,
            rev = rev, dirs = afp_dirs(afp_root, afp_rev))
        }
      }
    )
}

quality89%

¤ Dauer der Verarbeitung: 0.5 Sekunden ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.