1#!/usr/bin/env python3 2# -*- coding: utf-8 -*- 3 4# Copyright (c) 2021 Huawei Device Co., Ltd. 5# Licensed under the Apache License, Version 2.0 (the "License"); 6# you may not use this file except in compliance with the License. 7# You may obtain a copy of the License at 8# 9# http://www.apache.org/licenses/LICENSE-2.0 10# 11# Unless required by applicable law or agreed to in writing, software 12# distributed under the License is distributed on an "AS IS" BASIS, 13# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14# See the License for the specific language governing permissions and 15# limitations under the License. 16""" 17Description : Create script file for updater 18""" 19 20import os 21import re 22import tempfile 23from decimal import getcontext 24from decimal import Decimal 25 26from log_exception import VendorExpandError 27from log_exception import UPDATE_LOGGER 28from utils import OPTIONS_MANAGER 29from utils import PARTITION_FILE 30from utils import TOTAL_SCRIPT_FILE_NAME 31from utils import SCRIPT_FILE_NAME 32from utils import SCRIPT_KEY_LIST 33from utils import UPDATE_BIN_FILE_NAME 34 35 36class Script: 37 38 def __init__(self): 39 self.script = [] 40 self.version = 0 41 self.info = {} 42 43 def add_command(self, cmd=None): 44 """ 45 Add command content to the script. 46 :param cmd: command content 47 :return: 48 """ 49 self.script.append(cmd) 50 51 def get_script(self): 52 """ 53 Get the script list. 54 :return: script list 55 """ 56 return self.script 57 58 def sha_check(self, *args, **kwargs): 59 raise VendorExpandError(type(self), 'sha_check') 60 61 def image_sha_check(self, *args, **kwargs): 62 raise VendorExpandError(type(self), 'image_sha_check') 63 64 def first_block_check(self, *args, **kwargs): 65 raise VendorExpandError(type(self), 'first_block_check') 66 67 def image_patch(self, *args, **kwargs): 68 raise VendorExpandError(type(self), 'image_patch') 69 70 def abort(self, *args, **kwargs): 71 raise VendorExpandError(type(self), 'abort') 72 73 def show_progress(self, *args, **kwargs): 74 raise VendorExpandError(type(self), 'show_progress') 75 76 def block_update(self, *args, **kwargs): 77 raise VendorExpandError(type(self), 'block_update') 78 79 def raw_image_write(self, *args, **kwargs): 80 raise VendorExpandError(type(self), 'raw_image_write') 81 82 def get_status(self, *args, **kwargs): 83 raise VendorExpandError(type(self), 'get_status') 84 85 def set_status(self, *args, **kwargs): 86 raise VendorExpandError(type(self), 'set_status') 87 88 def reboot_now(self, *args, **kwargs): 89 raise VendorExpandError(type(self), 'reboot_now') 90 91 def updater_partitions(self, *args, **kwargs): 92 raise VendorExpandError(type(self), 'updater_partitions') 93 94 95class PreludeScript(Script): 96 def __init__(self): 97 super().__init__() 98 99 100class VerseScript(Script): 101 def __init__(self): 102 super().__init__() 103 104 def sha_check(self, ranges_str, expected_sha, partition): 105 """ 106 Get the sha_check command. 107 :param ranges_str: ranges string 108 :param expected_sha: hash value 109 :param partition: image name 110 :return: 111 """ 112 cmd = ('sha_check("/{partition}", "{ranges_str}", ' 113 '"{expected_sha}")').format( 114 ranges_str=ranges_str, 115 expected_sha=expected_sha, partition=partition) 116 return cmd 117 118 def image_sha_check(self, partition, src_size, src_hash, 119 dst_size, dst_hash): 120 """ 121 Get the image_sha_check command. 122 :param ranges_str: ranges string 123 :param expected_sha: hash value 124 :param partition: image name 125 :return: 126 """ 127 cmd = ('image_sha_check("/{partition}", ' 128 '"{src_size}", "{src_hash}", ' 129 '"{dst_size}", "{dst_hash}")').format( 130 partition=partition, src_size=src_size, src_hash=src_hash, 131 dst_size=dst_size, dst_hash=dst_hash) 132 return cmd 133 134 def first_block_check(self, partition): 135 """ 136 Get the first_block_check command. 137 :param partition: image name 138 :return: 139 """ 140 cmd = 'first_block_check("/{partition}")'.format( 141 partition=partition) 142 return cmd 143 144 def abort(self, partition): 145 """ 146 Get the abort command. 147 :param partition: image name 148 :return: 149 """ 150 cmd = 'abort("ERROR: {partition} partition ' \ 151 'fails to incremental check!");\n'.format( 152 partition=partition) 153 return cmd 154 155 def show_progress(self, start_progress, dur): 156 """ 157 Get the show_progress command. 158 'dur' may be zero to advance the progress via SetProgress 159 :param start_progress: start progress 160 :param dur: seconds 161 :return: 162 """ 163 cmd = 'show_progress({start_progress}, {dur});\n'.format( 164 start_progress=float(start_progress), dur=float(dur)) 165 return cmd 166 167 def image_patch(self, partition, src_size, src_hash, target_size, target_hash): 168 """ 169 Get the image_patch command. 170 :param partition: image name 171 :return: 172 """ 173 cmd = 'image_patch("/{partition}", "{src_size}", ' \ 174 '"{src_hash}", "{target_size}", "{target_hash}", ' \ 175 '"{partition}.patch.dat");\n'.format(partition=partition, src_size=src_size, 176 src_hash=src_hash, target_size=target_size, target_hash=target_hash) 177 return cmd 178 179 def block_update(self, partition): 180 """ 181 Get the block_update command. 182 :param partition: image name 183 :return: 184 """ 185 cmd = 'block_update("/{partition}", ' \ 186 '"{partition}.transfer.list", "{partition}.new.dat", ' \ 187 '"{partition}.patch.dat");\n'.format(partition=partition) 188 return cmd 189 190 def image_write(self, partition, image_name, image_path): 191 return self.raw_image_write(partition, image_name) 192 193 def raw_image_write(self, partition, image_name): 194 """ 195 Get the raw_image_write command. 196 :param partition: image name 197 :return: 198 """ 199 cmd = 'raw_image_write("/%s", "/%s");\n' % (partition, image_name) 200 return cmd 201 202 def get_status(self): 203 """ 204 Get the get_status command. 205 :return: 206 """ 207 cmd = 'get_status("/misc")' 208 return cmd 209 210 def set_status(self, status_value): 211 """ 212 Get the set_status command. 213 :param status_value: status value to be set 214 :return: 215 """ 216 cmd = 'set_status("/misc", %s);\n' % status_value 217 return cmd 218 219 def reboot_now(self): 220 """ 221 Get the reboot_now command. 222 :return: 223 """ 224 cmd = 'reboot_now();\n' 225 return cmd 226 227 def updater_partitions(self): 228 """ 229 Get the updater_partitions command. 230 :return: 231 """ 232 cmd = 'update_partitions("/%s");\n' % PARTITION_FILE 233 return cmd 234 235 def full_image_update(self, update_file_name): 236 cmd = 'update_from_bin("%s");\n' % update_file_name 237 return cmd 238 239 def pkg_extract(self, pkg_file_name, dest_path): 240 cmd = 'pkg_extract("%s", "%s");\n' % (pkg_file_name, dest_path) 241 return cmd 242 243 244class RefrainScript(Script): 245 def __init__(self): 246 super().__init__() 247 248 249class EndingScript(Script): 250 def __init__(self): 251 super().__init__() 252 253 254def write_script(script_content, opera_name): 255 """ 256 Generate the {opera}script. 257 :param script_content: script content 258 :param opera_name: Opera phase names corresponding to the script content 259 'prelude', 'verse', 'refrain', and 'ending'. 260 :return: 261 """ 262 script_file = tempfile.NamedTemporaryFile(mode='w+') 263 script_file.write(script_content) 264 script_file.seek(0) 265 script_file_name = ''.join([opera_name.title(), SCRIPT_FILE_NAME]) 266 OPTIONS_MANAGER.opera_script_file_name_dict[opera_name].\ 267 append((script_file_name, script_file)) 268 UPDATE_LOGGER.print_log("%s generation complete!" % script_file_name) 269 270 271def generate_total_script(): 272 """ 273 Generate the overall script. 274 """ 275 content_list = [] 276 for each_key, each_value in \ 277 OPTIONS_MANAGER.opera_script_file_name_dict.items(): 278 for each in each_value: 279 each_content = "LoadScript(\"%s\", %s);" % \ 280 (each[0], SCRIPT_KEY_LIST.index(each_key)) 281 content_list.append(each_content) 282 script_total = tempfile.NamedTemporaryFile(mode='w+') 283 script_total.write('\n'.join(content_list)) 284 script_total.seek(0) 285 OPTIONS_MANAGER.total_script_file_obj = script_total 286 UPDATE_LOGGER.print_log("%s generation complete!" % TOTAL_SCRIPT_FILE_NAME) 287 288 289def get_progress_value(distributable_value=100): 290 """ 291 Allocate a progress value to each image update. 292 :param distributable_value: distributable value 293 :return: 294 """ 295 progress_value_dict = {} 296 full_img_list = OPTIONS_MANAGER.full_img_list 297 incremental_img_list = OPTIONS_MANAGER.incremental_img_list 298 file_size_list = [] 299 each_img_size = 0 300 if len(full_img_list) == 0 and len(incremental_img_list) == 0: 301 UPDATE_LOGGER.print_log( 302 "get progress value failed! > getting progress value failed!", 303 UPDATE_LOGGER.ERROR_LOG) 304 return False 305 for partition in incremental_img_list: 306 # Obtain the size of the incremental image file. 307 if partition in OPTIONS_MANAGER.incremental_image_file_obj_dict: 308 file_obj = OPTIONS_MANAGER.incremental_image_file_obj_dict[partition] 309 each_img_size = os.path.getsize(file_obj.name) 310 elif partition in OPTIONS_MANAGER.incremental_block_file_obj_dict: 311 new_dat_file_obj, patch_dat_file_obj, transfer_list_file_obj =\ 312 OPTIONS_MANAGER.incremental_block_file_obj_dict[partition].get_file_obj() 313 each_img_size = os.path.getsize(new_dat_file_obj.name) + os.path.getsize(patch_dat_file_obj.name) 314 file_size_list.append(each_img_size) 315 316 total_full_img_size = 0 317 for idx, _ in enumerate(full_img_list): 318 # Obtain the size of the full image file. 319 file_obj = OPTIONS_MANAGER.full_image_file_obj_list[idx] 320 total_full_img_size += os.path.getsize(file_obj.name) 321 file_size_list.append(total_full_img_size) 322 323 proportion_value_list = get_proportion_value_list( 324 file_size_list, distributable_value=distributable_value) 325 326 adjusted_proportion_value_list = adjust_proportion_value_list( 327 proportion_value_list, distributable_value) 328 329 all_img_list = incremental_img_list + [UPDATE_BIN_FILE_NAME] 330 current_progress = 40 331 for idx, each_img in enumerate(all_img_list): 332 temp_progress = current_progress + adjusted_proportion_value_list[idx] 333 progress_value_dict[each_img] = (current_progress, temp_progress) 334 current_progress = temp_progress 335 return progress_value_dict 336 337 338def get_proportion_value_list(file_size_list, distributable_value=100): 339 """ 340 Obtain the calculated progress proportion value list 341 (proportion_value_list). 342 :param file_size_list: file size list 343 :param distributable_value: distributable value 344 :return proportion_value_list: progress proportion value list 345 """ 346 sum_size = sum(file_size_list) 347 getcontext().prec = 2 348 proportion_value_list = [] 349 for each_size_value in file_size_list: 350 proportion = Decimal(str(float(each_size_value))) / Decimal( 351 str(float(sum_size))) 352 proportion_value = int( 353 Decimal(str(proportion)) * 354 Decimal(str(float(distributable_value)))) 355 if proportion_value == 0: 356 proportion_value = 1 357 proportion_value_list.append(proportion_value) 358 return proportion_value_list 359 360 361def adjust_proportion_value_list(proportion_value_list, distributable_value): 362 """ 363 Adjust the calculated progress proportion value list to ensure that 364 sum is equal to distributable_value. 365 :param proportion_value_list: calculated progress proportion value list 366 :param distributable_value: number of distributable progress values 367 :return proportion_value_list: new progress proportion value list 368 """ 369 if len(proportion_value_list) == 0: 370 return [] 371 sum_proportion_value = sum(proportion_value_list) 372 if sum_proportion_value > distributable_value: 373 max_value = max(proportion_value_list) 374 max_idx = proportion_value_list.index(max_value) 375 proportion_value_list[max_idx] = \ 376 max_value - (sum_proportion_value - distributable_value) 377 elif sum_proportion_value < distributable_value: 378 min_value = min(proportion_value_list) 379 min_idx = proportion_value_list.index(min_value) 380 proportion_value_list[min_idx] = \ 381 min_value + (distributable_value - sum_proportion_value) 382 return proportion_value_list 383 384 385def create_script(prelude_script, verse_script, 386 refrain_script, ending_script): 387 """ 388 Generate the script file. 389 :param prelude_script: prelude script 390 :param verse_script: verse script 391 :param refrain_script: refrain script 392 :param ending_script: ending script 393 :return: 394 """ 395 # Generate the prelude script. 396 prelude_script.add_command("\n# ---- prelude ----\n") 397 398 # Get the distribution progress. 399 progress_value_dict = get_progress_value() 400 if progress_value_dict is False: 401 return False 402 verse_script_content_list = verse_script.get_script() 403 updater_content = [] 404 verse_script_content = '\n'.join(verse_script_content_list) 405 406 for key, value in progress_value_dict.items(): 407 show_progress_content = \ 408 verse_script.show_progress((value[1] - value[0]) / 100, 0) 409 verse_script_content = \ 410 re.sub(r'%s_WRITE_FLAG' % key, '%s' % show_progress_content, 411 verse_script_content, count=1) 412 # Generate the verse script. 413 write_script(verse_script_content, 'verse') 414 # Generate the refrain script. 415 refrain_script.add_command("\n# ---- refrain ----\n") 416 # Generate the ending script. 417 ending_script.add_command("\n# ---- ending ----\n") 418 419 generate_total_script() 420