Coverage for dak/admin.py: 45%

915 if cli_parser in (SUITE_CONFIG_READ_ONLY, SUITE_CONFIG_WRITABLE_ONLY_VIA_JSON): 915 ↛ 916line 915 didn't jump to line 916, because the condition on line 915 was never true

916 if cli_parser == SUITE_CONFIG_WRITABLE_ONLY_VIA_JSON:

917 msg = "Cannot parse value for %s" \

918 ''' - set via echo '{"%s": <...>}' | dak suite-config set-json %s instead'''

919 warn(msg % (conf_name, conf_name, suite_name))

920 die("Cannot change %s from the command line" % conf_name)

921 try:

922 new_value = cli_parser(new_value_str)

923 except (RuntimeError, ValueError, TypeError) as e:

924 warn("Could not parse new value for %s (given: %s)" % (conf_name, new_value_str))

925 raise e

926 try:

927 _set_suite_value(suite, conf_name, new_value)

928 except (RuntimeError, ValueError, TypeError) as e:

929 warn("Could not set new value for %s (given: %s)" % (conf_name, new_value))

930 raise e

931 if print_config_set:

932 print("%s=%s" % (conf_name, _get_suite_value(suite, conf_name)))

933

934

935def __suite_config_set_json(d, args):

936 session = d.session()

937 suite_name = args[2]

938 suite = get_suite_or_die(suite_name, session)

939 filename = '-'

940 if len(args) > 3:

941 if len(args) > 4:

942 warn("W: Ignoring extra argument after the json file name")

943 filename = args[3]

944 if filename != '-':

945 with open(filename) as fd:

946 update_config = json.load(fd)

947 else:

948 update_config = json.load(sys.stdin)

949 if update_config is None or not isinstance(update_config, dict):

950 die("E: suite-config set-json expects a dictionary (json object), got %s" % type(update_config))

951

952 for conf_name in sorted(update_config):

953 new_value = update_config[conf_name]

954 cli_parser = ALLOWED_SUITE_CONFIGS.get(conf_name)

955 if cli_parser is None:

956 die("Unknown (or unsupported) suite configuration variable: %s" % conf_name)

957 if cli_parser is SUITE_CONFIG_READ_ONLY:

958 die("Cannot change %s via JSON" % conf_name)

959 try:

960 _set_suite_value(suite, conf_name, new_value)

961 except (RuntimeError, ValueError, TypeError) as e:

962 warn("Could not set new value for %s (given: %s)" % (conf_name, new_value))

963 raise e

964 print("%s=%s" % (conf_name, _get_suite_value(suite, conf_name)))

965 if dryrun:

966 session.rollback()

967 print()

968 print("This was a dryrun; changes have been rolled back")

969 else:

970 session.commit()

971

972

973def __suite_config_list(d, args, json_format=False):

974 suite = None

975 session = d.session()

976 if len(args) > 3: 976 ↛ 977line 976 didn't jump to line 977, because the condition on line 976 was never true

977 warn("W: Ignoring extra argument after the suite name")

978 if len(args) == 3: 978 ↛ 982line 978 didn't jump to line 982, because the condition on line 978 was never false

979 suite_name = args[2]

980 suite = get_suite_or_die(suite_name, session)

981 else:

982 if json_format:

983 die("E: suite-config list-json requires a suite name!")

984 print("Valid suite-config options manageable by this command:")

985 print()

986 values = {}

987

988 for arg in sorted(ALLOWED_SUITE_CONFIGS):

989 mode = 'writable'

990 if suite is not None: 990 ↛ 997line 990 didn't jump to line 997, because the condition on line 990 was never false

991 value = _get_suite_value(suite, arg)

992 if json_format: 992 ↛ 993line 992 didn't jump to line 993, because the condition on line 992 was never true

993 values[arg] = value

994 else:

995 print("%s=%s" % (arg, value))

996 else:

997 converter = ALLOWED_SUITE_CONFIGS[arg]

998 if converter is SUITE_CONFIG_READ_ONLY:

999 mode = 'read-only'

1000 elif converter is SUITE_CONFIG_WRITABLE_ONLY_VIA_JSON:

1001 mode = 'writeable (via set-json only)'

1002 print(" * %s (%s)" % (arg, mode))

1003 if json_format: 1003 ↛ 1004line 1003 didn't jump to line 1004, because the condition on line 1003 was never true

1004 print(json.dumps(values, indent=2, sort_keys=True))

1005

1006

1007def suite_config(args):

1008 Cnf = utils.get_conf()

1009 d = DBConn()

1010

1011 die_arglen(args, 2, "E: suite-config needs a command")

1012 mode = args[1].lower()

1013

1014 if mode in {'get', 'get-value', 'get-json'}:

1015 direct_value = False

1016 json_format = mode == 'get-json'

1017 if mode == 'get-value': 1017 ↛ 1018line 1017 didn't jump to line 1018, because the condition on line 1017 was never true

1018 direct_value = True

1019 if len(args) > 4:

1020 die("E: get-value must receive exactly one key to lookup")

1021 __suite_config_get(d, args, direct_value=direct_value, json_format=json_format)

1022 elif mode == 'set':

1023 __suite_config_set(d, args)

1024 elif mode == 'set-json': 1024 ↛ 1025line 1024 didn't jump to line 1025, because the condition on line 1024 was never true

1025 __suite_config_set_json(d, args)

1026 elif mode in {'list', 'list-json'}: 1026 ↛ 1030line 1026 didn't jump to line 1030, because the condition on line 1026 was never false

1027 json_format = mode == 'list-json'

1028 __suite_config_list(d, args, json_format=json_format)

1029 else:

1030 suite = get_suite(mode, d.session())

1031 if suite is not None:

1032 warn("Did you get the order of the suite and the subcommand wrong?")

1033 warn("Syntax: dak admin %s {get,set,...} <suite>" % args[0])

1034 die("E: suite-config command unknown")

1035

1036

1037dispatch['suite-config'] = suite_config

1038dispatch['suite-cfg'] = suite_config

1039dispatch['s-cfg'] = suite_config

1040

1041

1042################################################################################

1043

1044

1045def archive_list():

1046 session = DBConn().session()

1047 for archive in session.query(Archive).order_by(Archive.archive_name):

1048 print("{0} path={1} description={2} tainted={3}".format(archive.archive_name, archive.path, archive.description, archive.tainted))

1049

1050

1051def archive_add(args):

1052 (name, path, description) = args[0:3]

1053

1054 attributes = dict(

1055 archive_name=name,

1056 path=path,

1057 description=description,

1058 )

1059

1060 for option in args[3:]: 1060 ↛ 1061line 1060 didn't jump to line 1061, because the loop on line 1060 never started

1061 (key, value) = option.split('=')

1062 attributes[key] = value

1063

1064 session = DBConn().session()

1065

1066 archive = Archive()

1067 for key, value in attributes.items():

1068 setattr(archive, key, value)

1069

1070 session.add(archive)

1071 session.flush()

1072

1073 if dryrun: 1073 ↛ 1074line 1073 didn't jump to line 1074, because the condition on line 1073 was never true

1074 session.rollback()

1075 else:

1076 session.commit()

1077

1078

1079def archive_rm(name):

1080 session = DBConn().session()

1081 archive = get_archive(name, session)

1082 session.delete(archive)

1083 session.flush()

1084

1085 if dryrun:

1086 session.rollback()

1087 else:

1088 session.commit()

1089

1090

1091def archive_rename(oldname, newname):

1092 session = DBConn().session()

1093 archive = get_archive(oldname, session)

1094 archive.archive_name = newname

1095 session.flush()

1096

1097 if dryrun:

1098 session.rollback()

1099 else:

1100 session.commit()

1101

1102

1103def archive(command):

1104 mode = command[1]

1105 if mode == 'list':

1106 archive_list()

1107 elif mode == 'rename': 1107 ↛ 1108line 1107 didn't jump to line 1108, because the condition on line 1107 was never true

1108 archive_rename(command[2], command[3])

1109 elif mode == 'add': 1109 ↛ 1111line 1109 didn't jump to line 1111, because the condition on line 1109 was never false

1110 archive_add(command[2:])

1111 elif mode == 'rm':

1112 archive_rm(command[2])

1113 else:

1114 die("E: archive command unknown")

1115

1116

1117dispatch['archive'] = archive

1118

1119################################################################################

1120

1121

1122def __version_check_list(d):

1123 session = d.session()

1124 for s in session.query(Suite).order_by(Suite.suite_name):

1125 __version_check_list_suite(d, s.suite_name)

1126

1127

1128def __version_check_list_suite(d, suite_name):

1129 vcs = get_version_checks(suite_name)

1130 for vc in vcs:

1131 print("%s %s %s" % (suite_name, vc.check, vc.reference.suite_name))

1132

1133

1134def __version_check_add(d, suite_name, check, reference_name):

1135 suite = get_suite_or_die(suite_name,

1136 error_message="E: Could not find suite %(suite_name)s")

1137 reference = get_suite_or_die(reference_name,

1138 error_message="E: Could not find reference suite %(suite_name)s")

1139

1140 session = d.session()

1141 vc = VersionCheck()

1142 vc.suite = suite

1143 vc.check = check

1144 vc.reference = reference

1145 session.add(vc)

1146 session.commit()

1147

1148

1149def __version_check_rm(d, suite_name, check, reference_name):

1150 suite = get_suite_or_die(suite_name,

1151 error_message="E: Could not find suite %(suite_name)s")

1152 reference = get_suite_or_die(reference_name,

1153 error_message="E: Could not find reference suite %(suite_name)s")

1154

1155 session = d.session()

1156 try:

1157 vc = session.query(VersionCheck).filter_by(suite=suite, check=check, reference=reference).one()

1158 session.delete(vc)

1159 session.commit()

1160 except NoResultFound:

1161 print("W: version-check not found.")

1162

1163

1164def version_check(args):

1165 Cnf = utils.get_conf()

1166 d = DBConn()

1167

1168 die_arglen(args, 2, "E: version-check needs at least a command")

1169 mode = args[1].lower()

1170

1171 if mode == 'list': 1171 ↛ 1172line 1171 didn't jump to line 1172, because the condition on line 1171 was never true

1172 __version_check_list(d)

1173 elif mode == 'list-suite': 1173 ↛ 1174line 1173 didn't jump to line 1174, because the condition on line 1173 was never true

1174 if len(args) != 3:

1175 die("E: version-check list-suite needs a single parameter")

1176 __version_check_list_suite(d, args[2])

1177 elif mode == 'add': 1177 ↛ 1181line 1177 didn't jump to line 1181, because the condition on line 1177 was never false

1178 if len(args) != 5: 1178 ↛ 1179line 1178 didn't jump to line 1179, because the condition on line 1178 was never true

1179 die("E: version-check add needs three parameters")

1180 __version_check_add(d, args[2], args[3], args[4])

1181 elif mode == 'rm':

1182 if len(args) != 5:

1183 die("E: version-check rm needs three parameters")

1184 __version_check_rm(d, args[2], args[3], args[4])

1185 else:

1186 die("E: version-check command unknown")

1187

1188

1189dispatch['version-check'] = version_check

1190dispatch['v-c'] = version_check

1191

1192################################################################################

1193

1194

1195def show_config(args):

1196 cnf = utils.get_conf()

1197

1198 die_arglen(args, 2, "E: config needs at least a command")

1199

1200 mode = args[1].lower()

1201

1202 if mode == 'db':

1203 connstr = ""

1204 if "DB::Service" in cnf:

1205 # Service mode

1206 connstr = "postgresql://service=%s" % cnf["DB::Service"]

1207 elif "DB::Host" in cnf:

1208 # TCP/IP

1209 connstr = "postgresql://%s" % cnf["DB::Host"]

1210 if "DB::Port" in cnf and cnf["DB::Port"] != "-1":

1211 connstr += ":%s" % cnf["DB::Port"]

1212 connstr += "/%s" % cnf["DB::Name"]

1213 else:

1214 # Unix Socket

1215 connstr = "postgresql:///%s" % cnf["DB::Name"]

1216 if cnf["DB::Port"] and cnf["DB::Port"] != "-1":

1217 connstr += "?port=%s" % cnf["DB::Port"]

1218 print(connstr)

1219 elif mode == 'db-shell':

1220 e = []

1221 if "DB::Service" in cnf:

1222 e.append('PGSERVICE')

1223 print("PGSERVICE=%s" % cnf["DB::Service"])

1224 if "DB::Name" in cnf:

1225 e.append('PGDATABASE')

1226 print("PGDATABASE=%s" % cnf["DB::Name"])

1227 if "DB::Host" in cnf:

1228 print("PGHOST=%s" % cnf["DB::Host"])

1229 e.append('PGHOST')

1230 if "DB::Port" in cnf and cnf["DB::Port"] != "-1":

1231 print("PGPORT=%s" % cnf["DB::Port"])

1232 e.append('PGPORT')

1233 print("export " + " ".join(e))

1234 elif mode == 'get':

1235 print(cnf.get(args[2]))

1236 else:

1237 session = DBConn().session()

1238 try:

1239 o = session.query(DBConfig).filter_by(name=mode).one()

1240 print(o.value)

1241 except NoResultFound:

1242 print("W: option '%s' not set" % mode)

1243

1244

1245dispatch['config'] = show_config

1246dispatch['c'] = show_config

1247

1248################################################################################

1249

1250

1251def show_keyring(args):

1252 cnf = utils.get_conf()

1253

1254 die_arglen(args, 2, "E: keyring needs at least a command")

1255

1256 mode = args[1].lower()

1257

1258 d = DBConn()

1259

1260 q = d.session().query(Keyring).filter(Keyring.active == True) # noqa:E712

1261

1262 if mode == 'list-all':

1263 pass

1264 elif mode == 'list-binary':

1265 q = q.join(Keyring.acl).filter(ACL.allow_source == False) # noqa:E712

1266 elif mode == 'list-source':

1267 q = q.join(Keyring.acl).filter(ACL.allow_source == True) # noqa:E712

1268 else:

1269 die("E: keyring command unknown")

1270

1271 for k in q.all():

1272 print(k.keyring_name)

1273

1274

1275def keyring_add_buildd(command):

1276 name = command[2]

1277 arch_names = command[3:]

1278

1279 session = DBConn().session()

1280 arches = session.query(Architecture).filter(Architecture.arch_string.in_(arch_names))

1281

1282 acl = ACL()

1283 acl.name = 'buildd-{0}'.format('+'.join(arch_names))

1284 acl.architectures.update(arches)

1285 acl.allow_new = True

1286 acl.allow_binary = True

1287 acl.allow_binary_only = True

1288 acl.allow_hijack = True

1289 session.add(acl)

1290

1291 k = Keyring()

1292 k.keyring_name = name

1293 k.acl = acl

1294 k.priority = 10

1295 session.add(k)

1296

1297 session.commit()

1298

1299

1300def keyring(command):

1301 if command[1].startswith('list-'):

1302 show_keyring(command)

1303 elif command[1] == 'add-buildd':

1304 keyring_add_buildd(command)

1305 else:

1306 die("E: keyring command unknown")

1307

1308

1309dispatch['keyring'] = keyring

1310dispatch['k'] = keyring

1311

1312################################################################################

1313

1314

1315def change_component_source(transaction, suite, component, source_names):

1316 session = transaction.session

1317

1318 overrides = session.query(Override).filter(Override.package.in_(source_names)).filter_by(suite=suite).join(OverrideType).filter_by(overridetype='dsc')

1319 for override in overrides:

1320 print("Changing override for {0}".format(override.package))

1321 override.component = component

1322 session.flush()

1323

1324 sources = session.query(DBSource).filter(DBSource.source.in_(source_names)).filter(DBSource.suites.contains(suite))

1325 for source in sources:

1326 print("Copying {0}={1}".format(source.source, source.version))

1327 transaction.copy_source(source, suite, component)

1328

1329

1330def change_component_binary(transaction, suite, component, binary_names):

1331 session = transaction.session

1332

1333 overrides = session.query(Override).filter(Override.package.in_(binary_names)).filter_by(suite=suite).join(OverrideType).filter(OverrideType.overridetype.in_(['deb', 'udeb']))