Revision b8028dcf

b/lib/backend.py
68 68

  
69 69

  
70 70
_BOOT_ID_PATH = "/proc/sys/kernel/random/boot_id"
71
_ALLOWED_CLEAN_DIRS = frozenset([
71
_ALLOWED_CLEAN_DIRS = compat.UniqueFrozenset([
72 72
  pathutils.DATA_DIR,
73 73
  pathutils.JOB_QUEUE_ARCHIVE_DIR,
74 74
  pathutils.QUEUE_DIR,
b/lib/bdev.py
120 120
    paths.update(map(lambda s: "%s/%s" % (prefix, s),
121 121
                     ["bin", "lib", "lib32", "lib64", "sbin"]))
122 122

  
123
  return frozenset(map(os.path.normpath, paths))
123
  return compat.UniqueFrozenset(map(os.path.normpath, paths))
124 124

  
125 125

  
126 126
def _ComputeWrongFileStoragePaths(paths,
......
503 503

  
504 504
  """
505 505
  _VALID_NAME_RE = re.compile("^[a-zA-Z0-9+_.-]*$")
506
  _INVALID_NAMES = frozenset([".", "..", "snapshot", "pvmove"])
507
  _INVALID_SUBSTRINGS = frozenset(["_mlog", "_mimage"])
506
  _INVALID_NAMES = compat.UniqueFrozenset([".", "..", "snapshot", "pvmove"])
507
  _INVALID_SUBSTRINGS = compat.UniqueFrozenset(["_mlog", "_mimage"])
508 508

  
509 509
  def __init__(self, unique_id, children, size, params):
510 510
    """Attaches to a LV device.
......
958 958
  CS_SYNCTARGET = "SyncTarget"
959 959
  CS_PAUSEDSYNCS = "PausedSyncS"
960 960
  CS_PAUSEDSYNCT = "PausedSyncT"
961
  CSET_SYNC = frozenset([
961
  CSET_SYNC = compat.UniqueFrozenset([
962 962
    CS_WFREPORTPARAMS,
963 963
    CS_STARTINGSYNCS,
964 964
    CS_STARTINGSYNCT,
b/lib/cli.py
666 666
 OPT_COMPL_INST_ADD_NODES,
667 667
 OPT_COMPL_ONE_NODEGROUP) = range(100, 108)
668 668

  
669
OPT_COMPL_ALL = frozenset([
669
OPT_COMPL_ALL = compat.UniqueFrozenset([
670 670
  OPT_COMPL_MANY_NODES,
671 671
  OPT_COMPL_ONE_NODE,
672 672
  OPT_COMPL_ONE_INSTANCE,
b/lib/client/gnt_debug.py
432 432
   TM_MULTISUCCESS,
433 433
   TM_FAIL,
434 434
   TM_PARTFAIL) = range(4)
435
  TM_ALL = frozenset([TM_SUCCESS, TM_MULTISUCCESS, TM_FAIL, TM_PARTFAIL])
435
  TM_ALL = compat.UniqueFrozenset([
436
    TM_SUCCESS,
437
    TM_MULTISUCCESS,
438
    TM_FAIL,
439
    TM_PARTFAIL,
440
    ])
436 441

  
437 442
  for mode in TM_ALL:
438 443
    test_messages = [
b/lib/client/gnt_group.py
28 28
from ganeti import constants
29 29
from ganeti import opcodes
30 30
from ganeti import utils
31
from ganeti import compat
31 32
from cStringIO import StringIO
32 33

  
33 34

  
34 35
#: default list of fields for L{ListGroups}
35 36
_LIST_DEF_FIELDS = ["name", "node_cnt", "pinst_cnt", "alloc_policy", "ndparams"]
36 37

  
37

  
38
_ENV_OVERRIDE = frozenset(["list"])
38
_ENV_OVERRIDE = compat.UniqueFrozenset(["list"])
39 39

  
40 40

  
41 41
def AddGroup(opts, args):
b/lib/client/gnt_instance.py
53 53
_EXPAND_INSTANCES = "instances"
54 54
_EXPAND_INSTANCES_BY_TAGS = "instances-by-tags"
55 55

  
56
_EXPAND_NODES_TAGS_MODES = frozenset([
56
_EXPAND_NODES_TAGS_MODES = compat.UniqueFrozenset([
57 57
  _EXPAND_NODES_BOTH_BY_TAGS,
58 58
  _EXPAND_NODES_PRI_BY_TAGS,
59 59
  _EXPAND_NODES_SEC_BY_TAGS,
60 60
  ])
61 61

  
62

  
63 62
#: default list of options for L{ListInstances}
64 63
_LIST_DEF_FIELDS = [
65 64
  "name", "hypervisor", "os", "pnode", "status", "oper_ram",
66 65
  ]
67 66

  
68

  
69 67
_MISSING = object()
70
_ENV_OVERRIDE = frozenset(["list"])
68
_ENV_OVERRIDE = compat.UniqueFrozenset(["list"])
71 69

  
72 70
_INST_DATA_VAL = ht.TListOf(ht.TDict)
73 71

  
b/lib/client/gnt_node.py
39 39
from ganeti import netutils
40 40
from ganeti import pathutils
41 41
from ganeti import ssh
42
from ganeti import compat
42 43
from cStringIO import StringIO
43 44

  
44 45
from ganeti import confd
......
106 107

  
107 108
_MODIFIABLE_STORAGE_TYPES = constants.MODIFIABLE_STORAGE_FIELDS.keys()
108 109

  
110
_OOB_COMMAND_ASK = compat.UniqueFrozenset([
111
  constants.OOB_POWER_OFF,
112
  constants.OOB_POWER_CYCLE,
113
  ])
109 114

  
110
_OOB_COMMAND_ASK = frozenset([constants.OOB_POWER_OFF,
111
                              constants.OOB_POWER_CYCLE])
112

  
113

  
114
_ENV_OVERRIDE = frozenset(["list"])
115

  
115
_ENV_OVERRIDE = compat.UniqueFrozenset(["list"])
116 116

  
117 117
NONODE_SETUP_OPT = cli_option("--no-node-setup", default=True,
118 118
                              action="store_false", dest="node_setup",
b/lib/cmdlib.py
7288 7288
  HTYPE = constants.HTYPE_INSTANCE
7289 7289
  REQ_BGL = False
7290 7290

  
7291
  _MODIFYABLE = frozenset([
7291
  _MODIFYABLE = compat.UniqueFrozenset([
7292 7292
    constants.IDISK_SIZE,
7293 7293
    constants.IDISK_MODE,
7294 7294
    ])
b/lib/confd/client.py
406 406
# UPCALL_EXPIRE: internal library request expire
407 407
# has only salt, type, orig_request and extra_args
408 408
UPCALL_EXPIRE = 2
409
CONFD_UPCALL_TYPES = frozenset([
409
CONFD_UPCALL_TYPES = compat.UniqueFrozenset([
410 410
  UPCALL_REPLY,
411 411
  UPCALL_EXPIRE,
412 412
  ])
b/lib/constants.py
26 26

  
27 27
from ganeti import _autoconf
28 28
from ganeti import _vcsversion
29
from ganeti import compat
29 30
from ganeti import pathutils
30 31

  
31 32

  
......
34 35
OS_API_V10 = 10
35 36
OS_API_V15 = 15
36 37
OS_API_V20 = 20
37
OS_API_VERSIONS = frozenset([OS_API_V10, OS_API_V15, OS_API_V20])
38
OS_API_VERSIONS = compat.UniqueFrozenset([
39
  OS_API_V10,
40
  OS_API_V15,
41
  OS_API_V20,
42
  ])
38 43
VCS_VERSION = _vcsversion.VCS_VERSION
39 44
EXPORT_VERSION = 0
40 45
RAPI_VERSION = 2
......
223 228
CONS_MESSAGE = "msg"
224 229

  
225 230
#: All console types
226
CONS_ALL = frozenset([CONS_SSH, CONS_VNC, CONS_SPICE, CONS_MESSAGE])
231
CONS_ALL = compat.UniqueFrozenset([
232
  CONS_SSH,
233
  CONS_VNC,
234
  CONS_SPICE,
235
  CONS_MESSAGE,
236
  ])
227 237

  
228 238
# For RSA keys more bits are better, but they also make operations more
229 239
# expensive. NIST SP 800-131 recommends a minimum of 2048 bits from the year
......
256 266
# Import/export transport compression
257 267
IEC_NONE = "none"
258 268
IEC_GZIP = "gzip"
259
IEC_ALL = frozenset([
269
IEC_ALL = compat.UniqueFrozenset([
260 270
  IEC_NONE,
261 271
  IEC_GZIP,
262 272
  ])
......
322 332
SO_FIX_CONSISTENCY = "fix-consistency"
323 333

  
324 334
# Available fields per storage type
325
VALID_STORAGE_FIELDS = frozenset([
335
VALID_STORAGE_FIELDS = compat.UniqueFrozenset([
326 336
  SF_NAME,
327 337
  SF_TYPE,
328 338
  SF_SIZE,
......
331 341
  SF_ALLOCATABLE,
332 342
  ])
333 343

  
334
VALID_STORAGE_TYPES = frozenset([ST_FILE, ST_LVM_PV, ST_LVM_VG])
344
VALID_STORAGE_TYPES = compat.UniqueFrozenset([
345
  ST_FILE,
346
  ST_LVM_PV,
347
  ST_LVM_VG,
348
  ])
335 349

  
336 350
MODIFIABLE_STORAGE_FIELDS = {
337 351
  ST_LVM_PV: frozenset([SF_ALLOCATABLE]),
......
357 371
DT_RBD = "rbd"
358 372

  
359 373
# the set of network-mirrored disk templates
360
DTS_INT_MIRROR = frozenset([DT_DRBD8])
374
DTS_INT_MIRROR = compat.UniqueFrozenset([DT_DRBD8])
361 375

  
362 376
# the set of externally-mirrored disk templates (e.g. SAN, NAS)
363
DTS_EXT_MIRROR = frozenset([DT_SHARED_FILE, DT_BLOCK, DT_RBD])
377
DTS_EXT_MIRROR = compat.UniqueFrozenset([
378
  DT_SHARED_FILE,
379
  DT_BLOCK,
380
  DT_RBD,
381
  ])
364 382

  
365 383
# the set of non-lvm-based disk templates
366
DTS_NOT_LVM = frozenset([DT_DISKLESS, DT_FILE, DT_SHARED_FILE,
367
                         DT_BLOCK, DT_RBD])
384
DTS_NOT_LVM = compat.UniqueFrozenset([
385
  DT_DISKLESS,
386
  DT_FILE,
387
  DT_SHARED_FILE,
388
  DT_BLOCK,
389
  DT_RBD,
390
  ])
368 391

  
369 392
# the set of disk templates which can be grown
370
DTS_GROWABLE = frozenset([DT_PLAIN, DT_DRBD8, DT_FILE, DT_SHARED_FILE, DT_RBD])
393
DTS_GROWABLE = compat.UniqueFrozenset([
394
  DT_PLAIN,
395
  DT_DRBD8,
396
  DT_FILE,
397
  DT_SHARED_FILE,
398
  DT_RBD,
399
  ])
371 400

  
372 401
# the set of disk templates that allow adoption
373
DTS_MAY_ADOPT = frozenset([DT_PLAIN, DT_BLOCK])
402
DTS_MAY_ADOPT = compat.UniqueFrozenset([
403
  DT_PLAIN,
404
  DT_BLOCK,
405
  ])
374 406

  
375 407
# the set of disk templates that *must* use adoption
376
DTS_MUST_ADOPT = frozenset([DT_BLOCK])
408
DTS_MUST_ADOPT = compat.UniqueFrozenset([DT_BLOCK])
377 409

  
378 410
# the set of disk templates that allow migrations
379 411
DTS_MIRRORED = frozenset.union(DTS_INT_MIRROR, DTS_EXT_MIRROR)
380 412

  
381 413
# the set of file based disk templates
382
DTS_FILEBASED = frozenset([DT_FILE, DT_SHARED_FILE])
414
DTS_FILEBASED = compat.UniqueFrozenset([
415
  DT_FILE,
416
  DT_SHARED_FILE,
417
  ])
383 418

  
384 419
# logical disk types
385 420
LD_LV = "lvm"
......
387 422
LD_FILE = "file"
388 423
LD_BLOCKDEV = "blockdev"
389 424
LD_RBD = "rbd"
390
LOGICAL_DISK_TYPES = frozenset([
425
LOGICAL_DISK_TYPES = compat.UniqueFrozenset([
391 426
  LD_LV,
392 427
  LD_DRBD8,
393 428
  LD_FILE,
......
395 430
  LD_RBD,
396 431
  ])
397 432

  
398
LDS_BLOCK = frozenset([LD_LV, LD_DRBD8, LD_BLOCKDEV, LD_RBD])
433
LDS_BLOCK = compat.UniqueFrozenset([
434
  LD_LV,
435
  LD_DRBD8,
436
  LD_BLOCKDEV,
437
  LD_RBD,
438
  ])
399 439

  
400 440
# drbd constants
401 441
DRBD_HMAC_ALG = "md5"
......
412 452
DRBD_B_DISK_FLUSH = "f"
413 453

  
414 454
# Valid barrier combinations: "n" or any non-null subset of "bfd"
415
DRBD_VALID_BARRIER_OPT = frozenset([
455
DRBD_VALID_BARRIER_OPT = compat.UniqueFrozenset([
416 456
  frozenset([DRBD_B_NONE]),
417 457
  frozenset([DRBD_B_DISK_BARRIERS]),
418 458
  frozenset([DRBD_B_DISK_DRAIN]),
......
431 471
FD_BLKTAP = "blktap"
432 472

  
433 473
# the set of drbd-like disk types
434
LDS_DRBD = frozenset([LD_DRBD8])
474
LDS_DRBD = compat.UniqueFrozenset([LD_DRBD8])
435 475

  
436 476
# disk access mode
437 477
DISK_RDONLY = "ro"
438 478
DISK_RDWR = "rw"
439
DISK_ACCESS_SET = frozenset([DISK_RDONLY, DISK_RDWR])
479
DISK_ACCESS_SET = compat.UniqueFrozenset([DISK_RDONLY, DISK_RDWR])
440 480

  
441 481
# disk replacement mode
442 482
REPLACE_DISK_PRI = "replace_on_primary"    # replace disks on primary
443 483
REPLACE_DISK_SEC = "replace_on_secondary"  # replace disks on secondary
444 484
REPLACE_DISK_CHG = "replace_new_secondary" # change secondary node
445 485
REPLACE_DISK_AUTO = "replace_auto"
446
REPLACE_MODES = frozenset([
486
REPLACE_MODES = compat.UniqueFrozenset([
447 487
  REPLACE_DISK_PRI,
448 488
  REPLACE_DISK_SEC,
449 489
  REPLACE_DISK_CHG,
......
453 493
# Instance export mode
454 494
EXPORT_MODE_LOCAL = "local"
455 495
EXPORT_MODE_REMOTE = "remote"
456
EXPORT_MODES = frozenset([
496
EXPORT_MODES = compat.UniqueFrozenset([
457 497
  EXPORT_MODE_LOCAL,
458 498
  EXPORT_MODE_REMOTE,
459 499
  ])
......
462 502
INSTANCE_CREATE = "create"
463 503
INSTANCE_IMPORT = "import"
464 504
INSTANCE_REMOTE_IMPORT = "remote-import"
465
INSTANCE_CREATE_MODES = frozenset([
505
INSTANCE_CREATE_MODES = compat.UniqueFrozenset([
466 506
  INSTANCE_CREATE,
467 507
  INSTANCE_IMPORT,
468 508
  INSTANCE_REMOTE_IMPORT,
......
487 527
#: Give child process up to 5 seconds to exit after sending a signal
488 528
CHILD_LINGER_TIMEOUT = 5.0
489 529

  
490
DISK_TEMPLATES = frozenset([
530
DISK_TEMPLATES = compat.UniqueFrozenset([
491 531
  DT_DISKLESS,
492 532
  DT_PLAIN,
493 533
  DT_DRBD8,
......
497 537
  DT_RBD,
498 538
  ])
499 539

  
500
FILE_DRIVER = frozenset([FD_LOOP, FD_BLKTAP])
540
FILE_DRIVER = compat.UniqueFrozenset([FD_LOOP, FD_BLKTAP])
501 541

  
502 542
# import/export config options
503 543
INISECT_EXP = "export"
......
510 550
DDM_ADD = "add"
511 551
DDM_MODIFY = "modify"
512 552
DDM_REMOVE = "remove"
513
DDMS_VALUES = frozenset([DDM_ADD, DDM_REMOVE])
553
DDMS_VALUES = compat.UniqueFrozenset([DDM_ADD, DDM_REMOVE])
514 554
DDMS_VALUES_WITH_MODIFY = (DDMS_VALUES | frozenset([
515 555
  DDM_MODIFY,
516 556
  ]))
......
533 573
TAG_NODE = "node"
534 574
TAG_INSTANCE = "instance"
535 575
TAG_NETWORK = "network"
536
VALID_TAG_TYPES = frozenset([
576
VALID_TAG_TYPES = compat.UniqueFrozenset([
537 577
  TAG_CLUSTER,
538 578
  TAG_NODEGROUP,
539 579
  TAG_NODE,
......
552 592
IP6_ADDRESS_ANY = "::"
553 593
IP4_VERSION = 4
554 594
IP6_VERSION = 6
555
VALID_IP_VERSIONS = frozenset([IP4_VERSION, IP6_VERSION])
595
VALID_IP_VERSIONS = compat.UniqueFrozenset([IP4_VERSION, IP6_VERSION])
556 596
# for export to htools
557 597
IP4_FAMILY = socket.AF_INET
558 598
IP6_FAMILY = socket.AF_INET6
......
579 619
 RUNPARTS_RUN,
580 620
 RUNPARTS_ERR) = range(3)
581 621

  
582
RUNPARTS_STATUS = frozenset([RUNPARTS_SKIP, RUNPARTS_RUN, RUNPARTS_ERR])
622
RUNPARTS_STATUS = compat.UniqueFrozenset([
623
  RUNPARTS_SKIP,
624
  RUNPARTS_RUN,
625
  RUNPARTS_ERR,
626
  ])
583 627

  
584 628
# RPC constants
585 629
(RPC_ENCODING_NONE,
......
602 646
OS_SCRIPT_EXPORT = "export"
603 647
OS_SCRIPT_RENAME = "rename"
604 648
OS_SCRIPT_VERIFY = "verify"
605
OS_SCRIPTS = frozenset([
649
OS_SCRIPTS = compat.UniqueFrozenset([
606 650
  OS_SCRIPT_CREATE,
607 651
  OS_SCRIPT_IMPORT,
608 652
  OS_SCRIPT_EXPORT,
......
615 659
OS_PARAMETERS_FILE = "parameters.list"
616 660

  
617 661
OS_VALIDATE_PARAMETERS = "parameters"
618
OS_VALIDATE_CALLS = frozenset([OS_VALIDATE_PARAMETERS])
662
OS_VALIDATE_CALLS = compat.UniqueFrozenset([OS_VALIDATE_PARAMETERS])
619 663

  
620 664
# ssh constants
621 665
SSH = "ssh"
......
626 670
INSTANCE_REBOOT_HARD = "hard"
627 671
INSTANCE_REBOOT_FULL = "full"
628 672

  
629
REBOOT_TYPES = frozenset([
673
REBOOT_TYPES = compat.UniqueFrozenset([
630 674
  INSTANCE_REBOOT_SOFT,
631 675
  INSTANCE_REBOOT_HARD,
632 676
  INSTANCE_REBOOT_FULL,
......
636 680
INSTANCE_REBOOT_ALLOWED = "reboot"
637 681
INSTANCE_REBOOT_EXIT = "exit"
638 682

  
639
REBOOT_BEHAVIORS = frozenset([
683
REBOOT_BEHAVIORS = compat.UniqueFrozenset([
640 684
  INSTANCE_REBOOT_ALLOWED,
641 685
  INSTANCE_REBOOT_EXIT,
642 686
  ])
......
646 690
VTYPE_BOOL = "bool"
647 691
VTYPE_SIZE = "size" # size, in MiBs
648 692
VTYPE_INT = "int"
649
ENFORCEABLE_TYPES = frozenset([
693
ENFORCEABLE_TYPES = compat.UniqueFrozenset([
650 694
  VTYPE_STRING,
651 695
  VTYPE_MAYBE_STRING,
652 696
  VTYPE_BOOL,
......
797 841
HV_MIGRATION_FAILED = "failed"
798 842
HV_MIGRATION_CANCELLED = "cancelled"
799 843

  
800
HV_MIGRATION_VALID_STATUSES = frozenset([
844
HV_MIGRATION_VALID_STATUSES = compat.UniqueFrozenset([
801 845
  HV_MIGRATION_COMPLETED,
802 846
  HV_MIGRATION_ACTIVE,
803 847
  HV_MIGRATION_FAILED,
804 848
  HV_MIGRATION_CANCELLED,
805 849
  ])
806 850

  
807
HV_MIGRATION_FAILED_STATUSES = frozenset([
851
HV_MIGRATION_FAILED_STATUSES = compat.UniqueFrozenset([
808 852
  HV_MIGRATION_FAILED,
809 853
  HV_MIGRATION_CANCELLED,
810 854
  ])
......
858 902
  }
859 903

  
860 904
DSS_PARAMETERS = frozenset(DSS_PARAMETER_TYPES.keys())
861
DS_VALID_TYPES = frozenset([LD_LV])
905
DS_VALID_TYPES = compat.UniqueFrozenset([LD_LV])
862 906

  
863 907
# Backend parameter names
864 908
BE_MEMORY = "memory" # deprecated and replaced by max and min mem
......
918 962
IPOLICY_VCPU_RATIO = "vcpu-ratio"
919 963
IPOLICY_SPINDLE_RATIO = "spindle-ratio"
920 964

  
921
IPOLICY_ISPECS = frozenset([
965
IPOLICY_ISPECS = compat.UniqueFrozenset([
922 966
  ISPECS_MIN,
923 967
  ISPECS_MAX,
924 968
  ISPECS_STD,
925 969
  ])
926 970

  
927
IPOLICY_PARAMETERS = frozenset([
971
IPOLICY_PARAMETERS = compat.UniqueFrozenset([
928 972
  IPOLICY_VCPU_RATIO,
929 973
  IPOLICY_SPINDLE_RATIO,
930 974
  ])
......
1031 1075
OOB_POWER_STATUS = "power-status"
1032 1076
OOB_HEALTH = "health"
1033 1077

  
1034
OOB_COMMANDS = frozenset([
1078
OOB_COMMANDS = compat.UniqueFrozenset([
1035 1079
  OOB_POWER_ON,
1036 1080
  OOB_POWER_OFF,
1037 1081
  OOB_POWER_CYCLE,
......
1049 1093
OOB_STATUS_CRITICAL = "CRITICAL"
1050 1094
OOB_STATUS_UNKNOWN = "UNKNOWN"
1051 1095

  
1052
OOB_STATUSES = frozenset([
1096
OOB_STATUSES = compat.UniqueFrozenset([
1053 1097
  OOB_STATUS_OK,
1054 1098
  OOB_STATUS_WARNING,
1055 1099
  OOB_STATUS_CRITICAL,
......
1068 1112
NIC_MODE_OVS = "openvswitch"
1069 1113
NIC_IP_POOL = "pool"
1070 1114

  
1071
NIC_VALID_MODES = frozenset([NIC_MODE_BRIDGED, NIC_MODE_ROUTED, NIC_MODE_OVS])
1115
NIC_VALID_MODES = compat.UniqueFrozenset([
1116
  NIC_MODE_BRIDGED,
1117
  NIC_MODE_ROUTED,
1118
  NIC_MODE_OVS,
1119
  ])
1072 1120

  
1073 1121
RESERVE_ACTION = "reserve"
1074 1122
RELEASE_ACTION = "release"
......
1078 1126
NETWORK_TYPE_PRIVATE = "private"
1079 1127
NETWORK_TYPE_PUBLIC = "public"
1080 1128

  
1081
NETWORK_VALID_TYPES = frozenset([NETWORK_TYPE_PRIVATE, NETWORK_TYPE_PUBLIC])
1129
NETWORK_VALID_TYPES = compat.UniqueFrozenset([
1130
  NETWORK_TYPE_PRIVATE,
1131
  NETWORK_TYPE_PUBLIC,
1132
  ])
1082 1133

  
1083 1134
NICS_PARAMETER_TYPES = {
1084 1135
  NIC_MODE: VTYPE_STRING,
......
1124 1175
HT_KVM = "kvm"
1125 1176
HT_CHROOT = "chroot"
1126 1177
HT_LXC = "lxc"
1127
HYPER_TYPES = frozenset([
1178
HYPER_TYPES = compat.UniqueFrozenset([
1128 1179
  HT_XEN_PVM,
1129 1180
  HT_FAKE,
1130 1181
  HT_XEN_HVM,
......
1132 1183
  HT_CHROOT,
1133 1184
  HT_LXC,
1134 1185
  ])
1135
HTS_REQ_PORT = frozenset([HT_XEN_HVM, HT_KVM])
1186
HTS_REQ_PORT = compat.UniqueFrozenset([HT_XEN_HVM, HT_KVM])
1136 1187

  
1137 1188
VNC_BASE_PORT = 5900
1138 1189
VNC_DEFAULT_BIND_ADDRESS = IP4_ADDRESS_ANY
......
1148 1199
HT_NIC_E1000 = "e1000"
1149 1200
HT_NIC_PARAVIRTUAL = HT_DISK_PARAVIRTUAL = "paravirtual"
1150 1201

  
1151
HT_HVM_VALID_NIC_TYPES = frozenset([
1202
HT_HVM_VALID_NIC_TYPES = compat.UniqueFrozenset([
1152 1203
  HT_NIC_RTL8139,
1153 1204
  HT_NIC_NE2K_PCI,
1154 1205
  HT_NIC_E1000,
1155 1206
  HT_NIC_NE2K_ISA,
1156 1207
  HT_NIC_PARAVIRTUAL,
1157 1208
  ])
1158
HT_KVM_VALID_NIC_TYPES = frozenset([
1209
HT_KVM_VALID_NIC_TYPES = compat.UniqueFrozenset([
1159 1210
  HT_NIC_RTL8139,
1160 1211
  HT_NIC_NE2K_PCI,
1161 1212
  HT_NIC_NE2K_ISA,
......
1179 1230
HT_CACHE_NONE = "none"
1180 1231
HT_CACHE_WTHROUGH = "writethrough"
1181 1232
HT_CACHE_WBACK = "writeback"
1182
HT_VALID_CACHE_TYPES = frozenset([
1233
HT_VALID_CACHE_TYPES = compat.UniqueFrozenset([
1183 1234
  HT_CACHE_DEFAULT,
1184 1235
  HT_CACHE_NONE,
1185 1236
  HT_CACHE_WTHROUGH,
1186 1237
  HT_CACHE_WBACK,
1187 1238
  ])
1188 1239

  
1189
HT_HVM_VALID_DISK_TYPES = frozenset([HT_DISK_PARAVIRTUAL, HT_DISK_IOEMU])
1190
HT_KVM_VALID_DISK_TYPES = frozenset([
1240
HT_HVM_VALID_DISK_TYPES = compat.UniqueFrozenset([
1241
  HT_DISK_PARAVIRTUAL,
1242
  HT_DISK_IOEMU,
1243
  ])
1244
HT_KVM_VALID_DISK_TYPES = compat.UniqueFrozenset([
1191 1245
  HT_DISK_PARAVIRTUAL,
1192 1246
  HT_DISK_IDE,
1193 1247
  HT_DISK_SCSI,
......
1200 1254
HT_MOUSE_MOUSE = "mouse"
1201 1255
HT_MOUSE_TABLET = "tablet"
1202 1256

  
1203
HT_KVM_VALID_MOUSE_TYPES = frozenset([HT_MOUSE_MOUSE, HT_MOUSE_TABLET])
1257
HT_KVM_VALID_MOUSE_TYPES = compat.UniqueFrozenset([
1258
  HT_MOUSE_MOUSE,
1259
  HT_MOUSE_TABLET,
1260
  ])
1204 1261

  
1205 1262
# Boot order
1206 1263
HT_BO_FLOPPY = "floppy"
......
1208 1265
HT_BO_DISK = "disk"
1209 1266
HT_BO_NETWORK = "network"
1210 1267

  
1211
HT_KVM_VALID_BO_TYPES = frozenset([
1268
HT_KVM_VALID_BO_TYPES = compat.UniqueFrozenset([
1212 1269
  HT_BO_FLOPPY,
1213 1270
  HT_BO_CDROM,
1214 1271
  HT_BO_DISK,
......
1223 1280
HT_KVM_SPICE_LOSSLESS_IMG_COMPR_LZ = "lz"
1224 1281
HT_KVM_SPICE_LOSSLESS_IMG_COMPR_OFF = "off"
1225 1282

  
1226
HT_KVM_SPICE_VALID_LOSSLESS_IMG_COMPR_OPTIONS = frozenset([
1283
HT_KVM_SPICE_VALID_LOSSLESS_IMG_COMPR_OPTIONS = compat.UniqueFrozenset([
1227 1284
  HT_KVM_SPICE_LOSSLESS_IMG_COMPR_AUTO_GLZ,
1228 1285
  HT_KVM_SPICE_LOSSLESS_IMG_COMPR_AUTO_LZ,
1229 1286
  HT_KVM_SPICE_LOSSLESS_IMG_COMPR_QUIC,
......
1237 1294
HT_KVM_SPICE_LOSSY_IMG_COMPR_NEVER = "never"
1238 1295
HT_KVM_SPICE_LOSSY_IMG_COMPR_ALWAYS = "always"
1239 1296

  
1240
HT_KVM_SPICE_VALID_LOSSY_IMG_COMPR_OPTIONS = frozenset([
1297
HT_KVM_SPICE_VALID_LOSSY_IMG_COMPR_OPTIONS = compat.UniqueFrozenset([
1241 1298
  HT_KVM_SPICE_LOSSY_IMG_COMPR_AUTO,
1242 1299
  HT_KVM_SPICE_LOSSY_IMG_COMPR_NEVER,
1243 1300
  HT_KVM_SPICE_LOSSY_IMG_COMPR_ALWAYS,
......
1248 1305
HT_KVM_SPICE_VIDEO_STREAM_DETECTION_ALL = "all"
1249 1306
HT_KVM_SPICE_VIDEO_STREAM_DETECTION_FILTER = "filter"
1250 1307

  
1251
HT_KVM_SPICE_VALID_VIDEO_STREAM_DETECTION_OPTIONS = frozenset([
1308
HT_KVM_SPICE_VALID_VIDEO_STREAM_DETECTION_OPTIONS = compat.UniqueFrozenset([
1252 1309
  HT_KVM_SPICE_VIDEO_STREAM_DETECTION_OFF,
1253 1310
  HT_KVM_SPICE_VIDEO_STREAM_DETECTION_ALL,
1254 1311
  HT_KVM_SPICE_VIDEO_STREAM_DETECTION_FILTER,
......
1259 1316
HT_SM_USER = "user"
1260 1317
HT_SM_POOL = "pool"
1261 1318

  
1262
HT_KVM_VALID_SM_TYPES = frozenset([HT_SM_NONE, HT_SM_USER, HT_SM_POOL])
1319
HT_KVM_VALID_SM_TYPES = compat.UniqueFrozenset([
1320
  HT_SM_NONE,
1321
  HT_SM_USER,
1322
  HT_SM_POOL,
1323
  ])
1263 1324

  
1264 1325
# Kvm flag values
1265 1326
HT_KVM_ENABLED = "enabled"
1266 1327
HT_KVM_DISABLED = "disabled"
1267 1328

  
1268
HT_KVM_FLAG_VALUES = frozenset([HT_KVM_ENABLED, HT_KVM_DISABLED])
1329
HT_KVM_FLAG_VALUES = compat.UniqueFrozenset([HT_KVM_ENABLED, HT_KVM_DISABLED])
1269 1330

  
1270 1331
# Migration type
1271 1332
HT_MIGRATION_LIVE = "live"
1272 1333
HT_MIGRATION_NONLIVE = "non-live"
1273
HT_MIGRATION_MODES = frozenset([HT_MIGRATION_LIVE, HT_MIGRATION_NONLIVE])
1334
HT_MIGRATION_MODES = compat.UniqueFrozenset([
1335
  HT_MIGRATION_LIVE,
1336
  HT_MIGRATION_NONLIVE,
1337
  ])
1274 1338

  
1275 1339
# Cluster Verify steps
1276 1340
VERIFY_NPLUSONE_MEM = "nplusone_mem"
1277
VERIFY_OPTIONAL_CHECKS = frozenset([VERIFY_NPLUSONE_MEM])
1341
VERIFY_OPTIONAL_CHECKS = compat.UniqueFrozenset([VERIFY_NPLUSONE_MEM])
1278 1342

  
1279 1343
# Cluster Verify error classes
1280 1344
CV_TCLUSTER = "cluster"
......
1358 1422
CV_ENODEFILESTORAGEPATHS = \
1359 1423
  (CV_TNODE, "ENODEFILESTORAGEPATHS", "Detected bad file storage paths")
1360 1424

  
1361
CV_ALL_ECODES = frozenset([
1425
CV_ALL_ECODES = compat.UniqueFrozenset([
1362 1426
  CV_ECLUSTERCFG,
1363 1427
  CV_ECLUSTERCERT,
1364 1428
  CV_ECLUSTERFILECHECK,
......
1393 1457
  CV_ENODEFILESTORAGEPATHS,
1394 1458
  ])
1395 1459

  
1396
CV_ALL_ECODES_STRINGS = frozenset(estr for (_, estr, _) in CV_ALL_ECODES)
1460
CV_ALL_ECODES_STRINGS = \
1461
  compat.UniqueFrozenset(estr for (_, estr, _) in CV_ALL_ECODES)
1397 1462

  
1398 1463
# Node verify constants
1399 1464
NV_DRBDHELPER = "drbd-helper"
......
1428 1493
INSTST_WRONGNODE = "ERROR_wrongnode"
1429 1494
INSTST_ERRORUP = "ERROR_up"
1430 1495
INSTST_ERRORDOWN = "ERROR_down"
1431
INSTST_ALL = frozenset([
1496
INSTST_ALL = compat.UniqueFrozenset([
1432 1497
  INSTST_RUNNING,
1433 1498
  INSTST_ADMINDOWN,
1434 1499
  INSTST_ADMINOFFLINE,
......
1443 1508
ADMINST_UP = "up"
1444 1509
ADMINST_DOWN = "down"
1445 1510
ADMINST_OFFLINE = "offline"
1446
ADMINST_ALL = frozenset([
1511
ADMINST_ALL = compat.UniqueFrozenset([
1447 1512
  ADMINST_UP,
1448 1513
  ADMINST_DOWN,
1449 1514
  ADMINST_OFFLINE,
......
1455 1520
NR_MCANDIDATE = "C"
1456 1521
NR_DRAINED = "D"
1457 1522
NR_OFFLINE = "O"
1458
NR_ALL = frozenset([
1523
NR_ALL = compat.UniqueFrozenset([
1459 1524
  NR_REGULAR,
1460 1525
  NR_MASTER,
1461 1526
  NR_MCANDIDATE,
......
1471 1536
IALLOCATOR_VERSION = 2
1472 1537
IALLOCATOR_DIR_IN = "in"
1473 1538
IALLOCATOR_DIR_OUT = "out"
1474
VALID_IALLOCATOR_DIRECTIONS = frozenset([
1539
VALID_IALLOCATOR_DIRECTIONS = compat.UniqueFrozenset([
1475 1540
  IALLOCATOR_DIR_IN,
1476 1541
  IALLOCATOR_DIR_OUT,
1477 1542
  ])
......
1480 1545
IALLOCATOR_MODE_CHG_GROUP = "change-group"
1481 1546
IALLOCATOR_MODE_NODE_EVAC = "node-evacuate"
1482 1547
IALLOCATOR_MODE_MULTI_ALLOC = "multi-allocate"
1483
VALID_IALLOCATOR_MODES = frozenset([
1548
VALID_IALLOCATOR_MODES = compat.UniqueFrozenset([
1484 1549
  IALLOCATOR_MODE_ALLOC,
1485 1550
  IALLOCATOR_MODE_RELOC,
1486 1551
  IALLOCATOR_MODE_CHG_GROUP,
......
1493 1558
IALLOCATOR_NEVAC_PRI = "primary-only"
1494 1559
IALLOCATOR_NEVAC_SEC = "secondary-only"
1495 1560
IALLOCATOR_NEVAC_ALL = "all"
1496
IALLOCATOR_NEVAC_MODES = frozenset([
1561
IALLOCATOR_NEVAC_MODES = compat.UniqueFrozenset([
1497 1562
  IALLOCATOR_NEVAC_PRI,
1498 1563
  IALLOCATOR_NEVAC_SEC,
1499 1564
  IALLOCATOR_NEVAC_ALL,
......
1503 1568
NODE_EVAC_PRI = "primary-only"
1504 1569
NODE_EVAC_SEC = "secondary-only"
1505 1570
NODE_EVAC_ALL = "all"
1506
NODE_EVAC_MODES = frozenset([
1571
NODE_EVAC_MODES = compat.UniqueFrozenset([
1507 1572
  NODE_EVAC_PRI,
1508 1573
  NODE_EVAC_SEC,
1509 1574
  NODE_EVAC_ALL,
......
1527 1592
JOB_STATUS_CANCELED = "canceled"
1528 1593
JOB_STATUS_SUCCESS = "success"
1529 1594
JOB_STATUS_ERROR = "error"
1530
JOBS_PENDING = frozenset([
1595
JOBS_PENDING = compat.UniqueFrozenset([
1531 1596
  JOB_STATUS_QUEUED,
1532 1597
  JOB_STATUS_WAITING,
1533 1598
  JOB_STATUS_CANCELING,
1534 1599
  ])
1535
JOBS_FINALIZED = frozenset([
1600
JOBS_FINALIZED = compat.UniqueFrozenset([
1536 1601
  JOB_STATUS_CANCELED,
1537 1602
  JOB_STATUS_SUCCESS,
1538 1603
  JOB_STATUS_ERROR,
1539 1604
  ])
1540
JOB_STATUS_ALL = frozenset([
1605
JOB_STATUS_ALL = compat.UniqueFrozenset([
1541 1606
  JOB_STATUS_RUNNING,
1542 1607
  ]) | JOBS_PENDING | JOBS_FINALIZED
1543 1608

  
......
1551 1616
OP_STATUS_CANCELED = "canceled"
1552 1617
OP_STATUS_SUCCESS = "success"
1553 1618
OP_STATUS_ERROR = "error"
1554
OPS_FINALIZED = frozenset([
1619
OPS_FINALIZED = compat.UniqueFrozenset([
1555 1620
  OP_STATUS_CANCELED,
1556 1621
  OP_STATUS_SUCCESS,
1557 1622
  OP_STATUS_ERROR,
......
1565 1630
OP_PRIO_NORMAL = 0
1566 1631
OP_PRIO_HIGH = -10
1567 1632

  
1568
OP_PRIO_SUBMIT_VALID = frozenset([
1633
OP_PRIO_SUBMIT_VALID = compat.UniqueFrozenset([
1569 1634
  OP_PRIO_LOW,
1570 1635
  OP_PRIO_NORMAL,
1571 1636
  OP_PRIO_HIGH,
......
1601 1666
JQT_EXEC = "exec"
1602 1667
JQT_LOGMSG = "logmsg"
1603 1668
JQT_STARTMSG = "startmsg"
1604
JQT_ALL = frozenset([
1669
JQT_ALL = compat.UniqueFrozenset([
1605 1670
  JQT_EXPANDNAMES,
1606 1671
  JQT_EXEC,
1607 1672
  JQT_LOGMSG,
......
1620 1685
QR_NETWORK = "network"
1621 1686

  
1622 1687
#: List of resources which can be queried using L{opcodes.OpQuery}
1623
QR_VIA_OP = frozenset([
1688
QR_VIA_OP = compat.UniqueFrozenset([
1624 1689
  QR_CLUSTER,
1625 1690
  QR_INSTANCE,
1626 1691
  QR_NODE,
......
1649 1714
QFT_OTHER = "other"
1650 1715

  
1651 1716
#: All query field types
1652
QFT_ALL = frozenset([
1717
QFT_ALL = compat.UniqueFrozenset([
1653 1718
  QFT_UNKNOWN,
1654 1719
  QFT_TEXT,
1655 1720
  QFT_BOOL,
......
1674 1739
#: Resource marked offline
1675 1740
RS_OFFLINE = 4
1676 1741

  
1677
RS_ALL = frozenset([
1742
RS_ALL = compat.UniqueFrozenset([
1678 1743
  RS_NORMAL,
1679 1744
  RS_UNKNOWN,
1680 1745
  RS_NODATA,
......
1821 1886
    },
1822 1887
  }
1823 1888

  
1824
HVC_GLOBALS = frozenset([
1889
HVC_GLOBALS = compat.UniqueFrozenset([
1825 1890
  HV_MIGRATION_PORT,
1826 1891
  HV_MIGRATION_BANDWIDTH,
1827 1892
  HV_MIGRATION_MODE,
......
1971 2036
CONFD_REQFIELD_IP = "1"
1972 2037
CONFD_REQFIELD_MNODE_PIP = "2"
1973 2038

  
1974
CONFD_REQS = frozenset([
2039
CONFD_REQS = compat.UniqueFrozenset([
1975 2040
  CONFD_REQ_PING,
1976 2041
  CONFD_REQ_NODE_ROLE_BYNAME,
1977 2042
  CONFD_REQ_NODE_PIP_BY_INSTANCE_IP,
......
1986 2051
CONFD_REPL_STATUS_ERROR = 1
1987 2052
CONFD_REPL_STATUS_NOTIMPLEMENTED = 2
1988 2053

  
1989
CONFD_REPL_STATUSES = frozenset([
2054
CONFD_REPL_STATUSES = compat.UniqueFrozenset([
1990 2055
  CONFD_REPL_STATUS_OK,
1991 2056
  CONFD_REPL_STATUS_ERROR,
1992 2057
  CONFD_REPL_STATUS_NOTIMPLEMENTED,
......
2080 2145
# SSH key types
2081 2146
SSHK_RSA = "rsa"
2082 2147
SSHK_DSA = "dsa"
2083
SSHK_ALL = frozenset([SSHK_RSA, SSHK_DSA])
2148
SSHK_ALL = compat.UniqueFrozenset([SSHK_RSA, SSHK_DSA])
2084 2149

  
2085 2150
# SSH authorized key types
2086 2151
SSHAK_RSA = "ssh-rsa"
2087 2152
SSHAK_DSS = "ssh-dss"
2088
SSHAK_ALL = frozenset([SSHAK_RSA, SSHAK_DSS])
2153
SSHAK_ALL = compat.UniqueFrozenset([SSHAK_RSA, SSHAK_DSS])
2089 2154

  
2090 2155
# SSH setup
2091 2156
SSHS_CLUSTER_NAME = "cluster_name"
......
2106 2171
NDS_START_NODE_DAEMON = "start_node_daemon"
2107 2172

  
2108 2173
# Do not re-export imported modules
2109
del re, _vcsversion, _autoconf, socket, pathutils
2174
del re, _vcsversion, _autoconf, socket, pathutils, compat
b/lib/errors.py
19 19
# 02110-1301, USA.
20 20

  
21 21

  
22
"""Ganeti exception handling"""
22
"""Ganeti exception handling.
23

  
24
"""
25

  
26
from ganeti import compat
23 27

  
24 28

  
25 29
# OpPrereqError failure types
......
55 59
ECODE_ENVIRON = "environment_error"
56 60

  
57 61
#: List of all failure types
58
ECODE_ALL = frozenset([
62
ECODE_ALL = compat.UniqueFrozenset([
59 63
  ECODE_RESOLVER,
60 64
  ECODE_NORES,
61 65
  ECODE_TEMP_NORES,
b/lib/impexpd/__init__.py
36 36
from ganeti import errors
37 37
from ganeti import utils
38 38
from ganeti import netutils
39
from ganeti import compat
39 40

  
40 41

  
41 42
#: Used to recognize point at which socat(1) starts to listen on its socket.
......
56 57
SOCAT_LOG_ERROR = "E"
57 58
SOCAT_LOG_FATAL = "F"
58 59

  
59
SOCAT_LOG_IGNORE = frozenset([
60
SOCAT_LOG_IGNORE = compat.UniqueFrozenset([
60 61
  SOCAT_LOG_DEBUG,
61 62
  SOCAT_LOG_INFO,
62 63
  SOCAT_LOG_NOTICE,
......
93 94
 PROG_DD,
94 95
 PROG_DD_PID,
95 96
 PROG_EXP_SIZE) = range(1, 6)
96
PROG_ALL = frozenset([
97

  
98
PROG_ALL = compat.UniqueFrozenset([
97 99
  PROG_OTHER,
98 100
  PROG_SOCAT,
99 101
  PROG_DD,
b/lib/locking.py
56 56
 _LS_ACQUIRE_ALL,
57 57
 _LS_ACQUIRE_OPPORTUNISTIC) = range(1, 4)
58 58

  
59
_LS_ACQUIRE_MODES = frozenset([
59
_LS_ACQUIRE_MODES = compat.UniqueFrozenset([
60 60
  _LS_ACQUIRE_EXACT,
61 61
  _LS_ACQUIRE_ALL,
62 62
  _LS_ACQUIRE_OPPORTUNISTIC,
......
1599 1599
  ]
1600 1600

  
1601 1601
# Lock levels which are modifiable
1602
LEVELS_MOD = frozenset([
1602
LEVELS_MOD = compat.UniqueFrozenset([
1603 1603
  LEVEL_NODE_RES,
1604 1604
  LEVEL_NODE,
1605 1605
  LEVEL_NODEGROUP,
b/lib/luxi.py
35 35
import errno
36 36
import logging
37 37

  
38
from ganeti import compat
38 39
from ganeti import serializer
39 40
from ganeti import constants
40 41
from ganeti import errors
......
71 72
REQ_SET_WATCHER_PAUSE = "SetWatcherPause"
72 73

  
73 74
#: List of all LUXI requests
74
REQ_ALL = frozenset([
75
REQ_ALL = compat.UniqueFrozenset([
75 76
  REQ_ARCHIVE_JOB,
76 77
  REQ_AUTO_ARCHIVE_JOBS,
77 78
  REQ_CANCEL_JOB,
b/lib/mcpu.py
50 50

  
51 51
#: LU classes which don't need to acquire the node allocation lock
52 52
#: (L{locking.NAL}) when they acquire all node or node resource locks
53
_NODE_ALLOC_WHITELIST = frozenset()
53
_NODE_ALLOC_WHITELIST = frozenset([])
54 54

  
55 55
#: LU classes which don't need to acquire the node allocation lock
56 56
#: (L{locking.NAL}) in the same mode (shared/exclusive) as the node
57 57
#: or node resource locks
58
_NODE_ALLOC_MODE_WHITELIST = frozenset([
58
_NODE_ALLOC_MODE_WHITELIST = compat.UniqueFrozenset([
59 59
  cmdlib.LUBackupExport,
60 60
  cmdlib.LUBackupRemove,
61 61
  cmdlib.LUOobCommand,
b/lib/pathutils.py
24 24
"""
25 25

  
26 26
from ganeti import _autoconf
27
from ganeti import compat
27 28
from ganeti import vcluster
28 29

  
29 30

  
......
130 131
JOB_QUEUE_ARCHIVE_DIR = QUEUE_DIR + "/archive"
131 132
JOB_QUEUE_DRAIN_FILE = QUEUE_DIR + "/drain"
132 133

  
133
ALL_CERT_FILES = frozenset([
134
ALL_CERT_FILES = compat.UniqueFrozenset([
134 135
  NODED_CERT_FILE,
135 136
  RAPI_CERT_FILE,
136 137
  SPICE_CERT_FILE,
b/lib/query.py
137 137
_FS_OFFLINE = object()
138 138

  
139 139
#: List of all special status
140
_FS_ALL = frozenset([_FS_UNKNOWN, _FS_NODATA, _FS_UNAVAIL, _FS_OFFLINE])
140
_FS_ALL = compat.UniqueFrozenset([
141
  _FS_UNKNOWN,
142
  _FS_NODATA,
143
  _FS_UNAVAIL,
144
  _FS_OFFLINE,
145
  ])
141 146

  
142 147
#: VType to QFT mapping
143 148
_VTToQFT = {
b/lib/rapi/__init__.py
1 1
#
2 2
#
3 3

  
4
# Copyright (C) 2007, 2008 Google Inc.
4
# Copyright (C) 2007, 2008, 2012 Google Inc.
5 5
#
6 6
# This program is free software; you can redistribute it and/or modify
7 7
# it under the terms of the GNU General Public License as published by
......
20 20

  
21 21
"""Ganeti RAPI module"""
22 22

  
23
from ganeti import compat
24

  
25

  
23 26
RAPI_ACCESS_WRITE = "write"
24 27
RAPI_ACCESS_READ = "read"
25 28

  
26
RAPI_ACCESS_ALL = frozenset([
29
RAPI_ACCESS_ALL = compat.UniqueFrozenset([
27 30
  RAPI_ACCESS_WRITE,
28 31
  RAPI_ACCESS_READ,
29 32
  ])
b/lib/rapi/baserlib.py
42 42
_DEFAULT = object()
43 43

  
44 44
#: Supported HTTP methods
45
_SUPPORTED_METHODS = frozenset([
45
_SUPPORTED_METHODS = compat.UniqueFrozenset([
46 46
  http.HTTP_DELETE,
47 47
  http.HTTP_GET,
48 48
  http.HTTP_POST,
b/lib/rapi/rlib2.py
155 155
# Feature string for node evacuation with LU-generated jobs
156 156
_NODE_EVAC_RES1 = "node-evac-res1"
157 157

  
158
ALL_FEATURES = frozenset([
158
ALL_FEATURES = compat.UniqueFrozenset([
159 159
  _INST_CREATE_REQV1,
160 160
  _INST_REINSTALL_REQV1,
161 161
  _NODE_MIGRATE_REQV1,
b/lib/ssconf.py
30 30
import errno
31 31
import logging
32 32

  
33
from ganeti import compat
33 34
from ganeti import errors
34 35
from ganeti import constants
35 36
from ganeti import utils
......
40 41
SSCONF_LOCK_TIMEOUT = 10
41 42

  
42 43
#: Valid ssconf keys
43
_VALID_KEYS = frozenset([
44
_VALID_KEYS = compat.UniqueFrozenset([
44 45
  constants.SS_CLUSTER_NAME,
45 46
  constants.SS_CLUSTER_TAGS,
46 47
  constants.SS_FILE_STORAGE_DIR,
b/lib/tools/ensure_dirs.py
35 35
from ganeti import utils
36 36
from ganeti import cli
37 37
from ganeti import pathutils
38
from ganeti import compat
38 39

  
39 40

  
40 41
(DIR,
41 42
 FILE,
42 43
 QUEUE_DIR) = range(1, 4)
43 44

  
44
ALL_TYPES = frozenset([
45
ALL_TYPES = compat.UniqueFrozenset([
45 46
  DIR,
46 47
  FILE,
47 48
  QUEUE_DIR,
b/lib/vcluster.py
39 39
_HOSTNAME_ENVNAME = "GANETI_HOSTNAME"
40 40

  
41 41
#: List of paths which shouldn't be virtualized
42
_VPATH_WHITELIST = frozenset([
42
_VPATH_WHITELIST = compat.UniqueFrozenset([
43 43
  ETC_HOSTS,
44 44
  ])
45 45

  
b/lib/watcher/__init__.py
59 59

  
60 60

  
61 61
MAXTRIES = 5
62
BAD_STATES = frozenset([
62
BAD_STATES = compat.UniqueFrozenset([
63 63
  constants.INSTST_ERRORDOWN,
64 64
  ])
65
HELPLESS_STATES = frozenset([
65
HELPLESS_STATES = compat.UniqueFrozenset([
66 66
  constants.INSTST_NODEDOWN,
67 67
  constants.INSTST_NODEOFFLINE,
68 68
  ])
b/qa/qa_rapi.py
104 104
               "mtotal", "mnode", "mfree",
105 105
               "pinst_cnt", "sinst_cnt", "tags")
106 106

  
107
GROUP_FIELDS = frozenset([
107
GROUP_FIELDS = compat.UniqueFrozenset([
108 108
  "name", "uuid",
109 109
  "alloc_policy",
110 110
  "node_cnt", "node_list",
111 111
  ])
112 112

  
113
JOB_FIELDS = frozenset([
113
JOB_FIELDS = compat.UniqueFrozenset([
114 114
  "id", "ops", "status", "summary",
115 115
  "opstatus", "opresult", "oplog",
116 116
  "received_ts", "start_ts", "end_ts",
b/test/docs_unittest.py
43 43

  
44 44
VALID_URI_RE = re.compile(r"^[-/a-z0-9]*$")
45 45

  
46
RAPI_OPCODE_EXCLUDE = frozenset([
46
RAPI_OPCODE_EXCLUDE = compat.UniqueFrozenset([
47 47
  # Not yet implemented
48 48
  opcodes.OpBackupQuery,
49 49
  opcodes.OpBackupRemove,
......
89 89

  
90 90

  
91 91
class TestHooksDocs(unittest.TestCase):
92
  HOOK_PATH_OK = frozenset([
92
  HOOK_PATH_OK = compat.UniqueFrozenset([
93 93
    "master-ip-turnup",
94 94
    "master-ip-turndown",
95 95
    ])
......
223 223

  
224 224
      prevline = line
225 225

  
226
    prefix_exception = frozenset(["/", "/version", "/2"])
226
    prefix_exception = compat.UniqueFrozenset(["/", "/version", "/2"])
227 227

  
228 228
    undocumented = []
229 229
    used_uris = []
b/test/ganeti.mcpu_unittest.py
25 25
import unittest
26 26
import itertools
27 27

  
28
from ganeti import compat
28 29
from ganeti import mcpu
29 30
from ganeti import opcodes
30 31
from ganeti import cmdlib
......
38 39
import testutils
39 40

  
40 41

  
41
REQ_BGL_WHITELIST = frozenset([
42
REQ_BGL_WHITELIST = compat.UniqueFrozenset([
42 43
  opcodes.OpClusterActivateMasterIp,
43 44
  opcodes.OpClusterDeactivateMasterIp,
44 45
  opcodes.OpClusterDestroy,
b/test/ganeti.opcodes_unittest.py
37 37

  
38 38
#: Unless an opcode is included in the following list it must have a result
39 39
#: check of some sort
40
MISSING_RESULT_CHECK = frozenset([
40
MISSING_RESULT_CHECK = compat.UniqueFrozenset([
41 41
  opcodes.OpTestAllocator,
42 42
  opcodes.OpTestDelay,
43 43
  opcodes.OpTestDummy,
b/test/ganeti.rapi.testutils_unittest.py
37 37
import testutils
38 38

  
39 39

  
40
KNOWN_UNUSED_LUXI = frozenset([
40
KNOWN_UNUSED_LUXI = compat.UniqueFrozenset([
41 41
  luxi.REQ_SUBMIT_MANY_JOBS,
42 42
  luxi.REQ_ARCHIVE_JOB,
43 43
  luxi.REQ_AUTO_ARCHIVE_JOBS,
b/tools/cluster-merge
41 41
from ganeti import ssh
42 42
from ganeti import utils
43 43
from ganeti import pathutils
44
from ganeti import compat
44 45

  
45 46

  
46 47
_GROUPS_MERGE = "merge"
......
134 135
  """Handling the merge.
135 136

  
136 137
  """
137
  RUNNING_STATUSES = frozenset([
138
  RUNNING_STATUSES = compat.UniqueFrozenset([
138 139
    constants.INSTST_RUNNING,
139 140
    constants.INSTST_ERRORUP,
140 141
    ])
b/tools/lvmstrap
68 68
  ]
69 69

  
70 70
#: Excluded filesystem types
71
EXCLUDED_FS = frozenset([
71
EXCLUDED_FS = compat.UniqueFrozenset([
72 72
  "nfs",
73 73
  "nfs4",
74 74
  "autofs",

Also available in: Unified diff