staging commit

master
cfig 3 weeks ago
parent 763427af01
commit 4af828484c

@ -15,7 +15,7 @@
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
plugins { plugins {
kotlin("jvm") version "2.0.20" kotlin("jvm") version "2.1.0"
application application
} }

@ -15,7 +15,7 @@
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
plugins { plugins {
kotlin("jvm") version "2.0.0" kotlin("jvm") version "2.1.0"
`java-library` `java-library`
application application
} }

@ -8,7 +8,7 @@
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
plugins { plugins {
kotlin("jvm") version "2.0.20" kotlin("jvm") version "2.1.0"
application application
} }

@ -70,7 +70,13 @@ fun main(args: Array<String>) {
if (args[0] == "apps") { if (args[0] == "apps") {
//AppList.retrieveList() //AppList.retrieveList()
} }
if (args[0] == "rel") {
ImageRelease.run()
}
if (args[0] == "x") { if (args[0] == "x") {
AMS.computeRankAndBucket(AMS.getProcRank(), AMS.getStandbyBucket2()) AMS.computeRankAndBucket(AMS.getProcRank(), AMS.getStandbyBucket2())
} }
if (args[0] == "mount") {
MountAnalyzer().run()
}
} }

@ -0,0 +1,67 @@
package cfig.lazybox
import cfig.helper.Helper
import cfig.helper.Helper.Companion.check_call
import org.slf4j.LoggerFactory
import java.io.File
import java.nio.file.Files
import java.nio.file.Paths
class ImageRelease {
companion object {
private val log = LoggerFactory.getLogger(ImageRelease::class.java)
fun run() {
val buildId = Helper.adbCmd("getprop ro.build.id").lowercase()
val variant = Helper.adbCmd("getprop ro.build.type")
val product = Helper.adbCmd("getprop ro.build.product")
val rel = Helper.adbCmd("getprop ro.build.version.release")
val increment = Helper.adbCmd("getprop ro.build.version.incremental")
val fp = Helper.adbCmd("getprop ro.build.fingerprint")
val computFacDir = "$product-factory-$buildId"
val computFacZip = "$product-factory-$buildId-$increment.zip"
val computOtaZip = "$product-ota-$buildId-$increment.zip"
val computEmmcZip = "$product-eMMCimg-$buildId-$increment.zip"
log.info("fingerprint: $fp")
log.info("$product-factory-$buildId-$increment -> $product-factory-$buildId")
log.info("$product-ota-$buildId-$increment")
log.info("$product-eMMCimg-$buildId-$increment")
//factory
if (File("factory.zip").exists()) {
"rm -fr factory_image factory_img $computFacDir $computFacZip".check_call()
"unzip factory.zip".check_call()
val facDir = if (File("factory_img").exists()) {
//user
"factory_img"
} else if (File("factory_image").exists()) {
//userdebug
"factory_image"
} else {
throw IllegalStateException("can not find factory image folder")
}
File(facDir).listFiles()?.filter { it.name.endsWith(".sh") }?.forEach { it.delete() }
"cp -v /tftp/flash_platypus.sh $facDir/flash.sh".check_call()
"mv -v $facDir $computFacDir".check_call()
"zip $computFacZip -r $computFacDir".check_call()
"rm -fr $computFacDir".check_call()
}
File("factory.zip").delete()
if (File("ota.zip").exists()) {
Files.move(Paths.get("ota.zip"), Paths.get(computOtaZip))
}
if (File("emmc.zip").exists()) {
Files.move(Paths.get("emmc.zip"), Paths.get(computEmmcZip))
}
log.info("fingerprint: $fp")
log.info("$product-factory-$buildId-$increment -> $product-factory-$buildId")
log.info(computFacZip)
log.info(computOtaZip)
log.info(computEmmcZip)
}
}
}

@ -0,0 +1,148 @@
package cfig.lazybox
import org.slf4j.LoggerFactory
import java.io.BufferedWriter
import java.io.File
import java.io.FileOutputStream
import java.io.FileWriter
class MountAnalyzer {
data class MountInfo(
var dev: String = "",
var mountPoint: String = "",
var fsType: String = "",
var flags: String? = null,
)
class MiComparator : Comparator<MountInfo> {
override fun compare(p1: MountInfo, p2: MountInfo): Int {
var ret = p1.fsType.compareTo(p2.fsType) * 100
ret += p1.dev.compareTo(p2.dev) * 10
ret += p1.mountPoint.compareTo(p2.mountPoint) * 1
return ret
}
}
fun run() {
val loopApex = mutableListOf<MountInfo>()
val dmApex = mutableListOf<MountInfo>()
val tmpApex = mutableListOf<MountInfo>()
val bootApex = mutableListOf<MountInfo>()
val fuseInfo = mutableListOf<MountInfo>()
val sysInfo = mutableListOf<MountInfo>()
val androidRo = mutableListOf<MountInfo>()
val androidRw = mutableListOf<MountInfo>()
val otherRw = mutableListOf<MountInfo>()
val unknownMi = mutableListOf<MountInfo>()
val lines = File("mount.log").readLines()
lines.forEachIndexed { n, line ->
val regex = Regex("(\\S+)\\s+on\\s+(\\S+)\\s+type\\s+(\\w+)\\s+\\(([^)]*)\\)") // Capture flags
val matchResult = regex.find(line)
if (matchResult != null) {
val dev = matchResult.groupValues[1]
val mountPoint = matchResult.groupValues[2]
val fsType = matchResult.groupValues[3]
val flags =
if (matchResult.groupValues.size > 4) matchResult.groupValues[4] else null // Handle no flags
val mi = MountInfo(dev, mountPoint, fsType, flags)
if (mi.mountPoint.startsWith("/apex") || mi.mountPoint.startsWith("/bootstrap-apex")) {
if (mi.mountPoint.startsWith("/bootstrap-apex")) {
bootApex.add(mi)
} else if (mi.dev.startsWith("/dev/block/loop")) {
loopApex.add(mi)
} else if (mi.dev.startsWith("/dev/block/dm")) {
dmApex.add(mi)
} else if (mi.dev.startsWith("tmpfs")) {
tmpApex.add(mi)
} else {
log.info("$fsType: $dev -> $mountPoint")
throw IllegalStateException("X1")
}
} else if (mi.mountPoint.startsWith("/sys/") || mi.mountPoint == "/sys") {
sysInfo.add(mi)
} else if (mi.fsType == "fuse") {
fuseInfo.add(mi)
} else {
log.info("$fsType: $dev -> $mountPoint")
if (mi.flags!!.contains("ro,") or mi.flags!!.contains("ro)")) {
androidRo.add(mi)
} else if (mi.flags!!.contains("rw,") or mi.flags!!.contains("rw)")) {
if (mi.dev.startsWith("/dev/")) {
androidRw.add(mi)
} else {
otherRw.add(mi)
}
} else {
throw IllegalStateException("X2")
}
}
} else { //For lines without flags
val regexNoFlags = Regex("(\\S+)\\s+on\\s+(\\S+)\\s+type\\s+(\\w+)")
val matchResultNoFlags = regexNoFlags.find(line)
if (matchResultNoFlags != null) {
val dev = matchResultNoFlags.groupValues[1]
val mountPoint = matchResultNoFlags.groupValues[2]
val fsType = matchResultNoFlags.groupValues[3]
val mi = MountInfo(dev, mountPoint, fsType, null)
unknownMi.add(mi)
} else {
throw IllegalStateException("X3")
}
}
} // end-of-lines
//sanity check, make sure consistent
check(
listOf(
loopApex,
dmApex,
tmpApex,
bootApex,
fuseInfo,
sysInfo,
androidRo,
androidRw,
otherRw,
unknownMi
).sumOf { it.size } == lines.size)
//dump
val infoNames = listOf(
"fusefs",
"sysfs",
"Android RO",
"Android RW",
"other Rw",
"loop apex",
"dm apex",
"tmp apex",
"boot apex",
"unknown"
)
BufferedWriter(FileWriter(File("sorted_mount.log"))).use { fos ->
listOf(
fuseInfo,
sysInfo,
androidRo,
androidRw,
otherRw,
loopApex,
dmApex,
tmpApex,
bootApex,
unknownMi
).forEachIndexed { n, mis ->
mis.sortWith(MiComparator())
log.info(infoNames.get(n))
fos.write(infoNames.get(n) + "\n")
mis.forEachIndexed { index, it ->
log.info("[$index] ${it.fsType} : ${it.dev} -> ${it.mountPoint} (${it.flags})")
fos.write("#$index | ${it.fsType} | ${it.dev} | ${it.mountPoint} | (${it.flags})\n")
}
fos.write("\n")
}
}
}
companion object {
private val log = LoggerFactory.getLogger(MountAnalyzer::class.java)
}
}
Loading…
Cancel
Save