cycode-cli/process_executable_file.py at main · cycodehq/cycode-cli · GitHub

History

executable file

188 lines (123 loc) · 5.5 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

#!/usr/bin/env python3

"""Used in the GitHub Actions workflow (build_executable.yml) to process the executable file.

This script calculates hash and renames executable file depending on the OS, arch, and build mode.

It also creates a file with the hash of the executable file.

It uses SHA256 algorithm to calculate the hash.

It returns the name of the executable file which is used as artifact name.

"""

import argparse

import hashlib

import os

import platform

import shutil

from pathlib import Path

from string import Template

from typing import Union

_ARCHIVE_FORMAT = 'zip'

_HASH_FILE_EXT = '.sha256'

_OS_TO_CLI_DIST_TEMPLATE = {

'darwin': Template('cycode-mac$suffix$ext'),

'linux': Template('cycode-linux$suffix$ext'),

'windows': Template('cycode-win$suffix$ext'),

}

_WINDOWS = 'windows'

_WINDOWS_EXECUTABLE_SUFFIX = '.exe'

DirHashes = list[tuple[str, str]]

def get_hash_of_file(file_path: Union[str, Path]) -> str:

with open(file_path, 'rb') as f:

return hashlib.sha256(f.read()).hexdigest()

def get_hashes_of_many_files(root: str, file_paths: list[str]) -> DirHashes:

hashes = []

for file_path in file_paths:

file_path = os.path.join(root, file_path)

file_hash = get_hash_of_file(file_path)

hashes.append((file_hash, file_path))

return hashes

def get_hashes_of_every_file_in_the_directory(dir_path: Path) -> DirHashes:

hashes = []

for root, _, files in os.walk(dir_path):

hashes.extend(

get_hashes_of_many_files(

root,

files,

)

return hashes

def normalize_hashes_db(hashes: DirHashes, dir_path: Path) -> DirHashes:

normalized_hashes = []

for file_hash, file_path in hashes:

relative_file_path = file_path[file_path.find(dir_path.name) :]

normalized_hashes.append((file_hash, relative_file_path))

# sort by file path

normalized_hashes.sort(key=lambda hash_item: hash_item[1])

return normalized_hashes

def is_arm() -> bool:

return platform.machine().lower() in ('arm', 'arm64', 'aarch64')

def get_os_name() -> str:

return platform.system().lower()

def get_cli_file_name(suffix: str = '', ext: str = '') -> str:

os_name = get_os_name()

if os_name not in _OS_TO_CLI_DIST_TEMPLATE:

raise Exception(f'Unsupported OS: {os_name}')

return _OS_TO_CLI_DIST_TEMPLATE[os_name].substitute(suffix=suffix, ext=ext)

def get_cli_file_suffix(is_onedir: bool) -> str:

suffixes = []

if is_arm():

suffixes.append('-arm')

if is_onedir:

suffixes.append('-onedir')

return ''.join(suffixes)

def write_hash_to_file(file_hash: str, output_path: str) -> None:

with open(output_path, 'w') as f:

f.write(file_hash)

def write_hashes_db_to_file(hashes: DirHashes, output_path: str) -> None:

content = ''

for file_hash, file_path in hashes:

content += f'{file_hash} {file_path}\n'

with open(output_path, 'w') as f:

f.write(content)

def get_cli_filename(is_onedir: bool) -> str:

# onedir is distributed as an archive of a directory, so only onefile carries .exe

ext = _WINDOWS_EXECUTABLE_SUFFIX if get_os_name() == _WINDOWS and not is_onedir else ''

return get_cli_file_name(suffix=get_cli_file_suffix(is_onedir), ext=ext)

def get_cli_path(output_path: Path, is_onedir: bool) -> str:

return os.path.join(output_path, get_cli_filename(is_onedir))

def get_cli_hash_filename(is_onedir: bool) -> str:

return get_cli_filename(is_onedir) + _HASH_FILE_EXT

def get_cli_hash_path(output_path: Path, is_onedir: bool) -> str:

return os.path.join(output_path, get_cli_hash_filename(is_onedir))

def get_cli_archive_filename(is_onedir: bool) -> str:

return get_cli_filename(is_onedir)

def get_cli_archive_path(output_path: Path, is_onedir: bool) -> str:

return os.path.join(output_path, get_cli_archive_filename(is_onedir))

def archive_directory(input_path: Path, output_path: str) -> None:

shutil.make_archive(output_path.removesuffix(f'.{_ARCHIVE_FORMAT}'), _ARCHIVE_FORMAT, input_path)

def process_executable_file(input_path: Path, is_onedir: bool) -> str:

output_path = input_path.parent

hash_file_path = get_cli_hash_path(output_path, is_onedir)

if is_onedir:

hashes = get_hashes_of_every_file_in_the_directory(input_path)

normalized_hashes = normalize_hashes_db(hashes, input_path)

write_hashes_db_to_file(normalized_hashes, hash_file_path)

archived_file_path = get_cli_archive_path(output_path, is_onedir)

archive_directory(input_path, f'{archived_file_path}.{_ARCHIVE_FORMAT}')

shutil.rmtree(input_path)

else:

file_hash = get_hash_of_file(input_path)

write_hash_to_file(file_hash, hash_file_path)

# for example rename cycode-cli to cycode-mac or cycode-mac-arm-onedir

os.rename(input_path, get_cli_path(output_path, is_onedir))

return get_cli_filename(is_onedir)

def main() -> None:

parser = argparse.ArgumentParser()

parser.add_argument('input', help='Path to executable or directory')

args = parser.parse_args()

input_path = Path(args.input)

is_onedir = input_path.is_dir()

if get_os_name() == _WINDOWS and not is_onedir and input_path.suffix != _WINDOWS_EXECUTABLE_SUFFIX:

# add .exe on windows if was missed (to simplify GHA workflow)

input_path = input_path.with_suffix(_WINDOWS_EXECUTABLE_SUFFIX)

artifact_name = process_executable_file(input_path, is_onedir)

print(artifact_name) # noqa: T201

if __name__ == '__main__':

main()

cycode-cli/process_executable_file.py at main · cycodehq/cycode-cli · GitHub

Uh oh!

Expand file tree

Breadcrumbs

process_executable_file.py

Latest commit

History

Breadcrumbs

process_executable_file.py

File metadata and controls