def update_filesystem(module, filesystem): """Update Filesystem""" changed = False if module.params['size']: size = Capacity(module.params['size']).roundup(64 * KiB) if filesystem.get_size() != size: if not module.check_mode: filesystem.update_size(size) changed = True return changed
def main(): argument_spec = infinibox_argument_spec() argument_spec.update( dict( name=dict(required=True), state=dict(default='present', choices=['present', 'absent']), size=dict(), vsize=dict(), ssd_cache=dict(type='bool', default=True) ) ) module = AnsibleModule(argument_spec, supports_check_mode=True) if not HAS_INFINISDK: module.fail_json(msg=missing_required_lib('infinisdk')) if not HAS_CAPACITY: module.fail_json(msg=missing_required_lib('capacity'), exception=CAPACITY_IMP_ERR) if module.params['size']: try: Capacity(module.params['size']) except Exception: module.fail_json(msg='size (Physical Capacity) should be defined in MB, GB, TB or PB units') if module.params['vsize']: try: Capacity(module.params['vsize']) except Exception: module.fail_json(msg='vsize (Virtual Capacity) should be defined in MB, GB, TB or PB units') state = module.params['state'] system = get_system(module) pool = get_pool(module, system) if state == 'present' and not pool: create_pool(module, system) elif state == 'present' and pool: update_pool(module, system, pool) elif state == 'absent' and pool: delete_pool(module, pool) elif state == 'absent' and not pool: module.exit_json(changed=False)
def create_filesystem(module, system): """Create Filesystem""" changed = True if not module.check_mode: filesystem = system.filesystems.create(name=module.params['name'], pool=get_pool(module, system)) if module.params['size']: size = Capacity(module.params['size']).roundup(64 * KiB) filesystem.update_size(size) return changed
def update_volume(module, volume): """Update Volume""" changed = False if module.params['size']: size = Capacity(module.params['size']).roundup(64 * KiB) if volume.get_size() != size: if not module.check_mode: volume.update_size(size) changed = True module.exit_json(changed=changed)
def __init__(self, json_struct=None): self.requestedCapacity = Capacity() #import self.latencyCharacteristic = KeyedArrayType(LatencyCharacteristic, 'trafficPropertyName') self._srcServiceEndPoint = "" self.serviceLevel = "" self.costCharacteristic = KeyedArrayType(CostCharacteristic, 'costName') self.serviceLayer = ArrayType.factory(str) self._diversityExclusion = ArrayType.factory(str) self._sinkServiceEndPoint = "" super(VirtualNetworkConstraint, self).__init__(json_struct)
def create_pool(module, system): """Create Pool""" name = module.params['name'] size = module.params['size'] vsize = module.params['vsize'] ssd_cache = module.params['ssd_cache'] if not module.check_mode: if not size and not vsize: pool = system.pools.create(name=name, physical_capacity=Capacity('1TB'), virtual_capacity=Capacity('1TB')) elif size and not vsize: pool = system.pools.create(name=name, physical_capacity=Capacity(size), virtual_capacity=Capacity(size)) elif not size and vsize: pool = system.pools.create(name=name, physical_capacity=Capacity('1TB'), virtual_capacity=Capacity(vsize)) else: pool = system.pools.create(name=name, physical_capacity=Capacity(size), virtual_capacity=Capacity(vsize)) # Default value of ssd_cache is True. Disable ssd chacing if False if not ssd_cache: pool.update_ssd_enabled(ssd_cache) module.exit_json(changed=True)
def main(): argument_spec = infinibox_argument_spec() argument_spec.update( dict( name=dict(required=True), state=dict(default='present', choices=['stat', 'present', 'absent']), size=dict(), vsize=dict(), ssd_cache=dict(type='bool', default=True), compression=dict(type='bool', default=True), )) module = AnsibleModule(argument_spec, supports_check_mode=True) if not HAS_INFINISDK: module.fail_json(msg=missing_required_lib('infinisdk')) if not HAS_CAPACITY: module.fail_json(msg=missing_required_lib('capacity'), exception=CAPACITY_IMP_ERR) if module.params['size']: try: Capacity(module.params['size']) except Exception: module.fail_json( msg= 'size (Physical Capacity) should be defined in MB, GB, TB or PB units' ) if module.params['vsize']: try: Capacity(module.params['vsize']) except Exception: module.fail_json( msg= 'vsize (Virtual Capacity) should be defined in MB, GB, TB or PB units' ) execute_state(module)
def __init__(self, json_struct=None): self.pathLayer = ArrayType.factory(str) self._excludePath = KeyedArrayType(TeLink, 'localId') self._includePath = KeyedArrayType(TeLink, 'localId') self.requestedCapacity = Capacity() #import self.costCharacteristic = KeyedArrayType(CostCharacteristic, 'costName') self._avoidTopology = ArrayType.factory(str) self.latencyCharacteristic = KeyedArrayType(LatencyCharacteristic, 'trafficPropertyName') self.serviceLevel = "" self._includeTopology = ArrayType.factory(str) super(RoutingConstraint, self).__init__(json_struct)
def update_pool(module, system, pool): """Update Pool""" changed = False size = module.params['size'] vsize = module.params['vsize'] #ssd_cache = module.params['ssd_cache'] compression = module.params['compression'] # Roundup the capacity to mimic Infinibox behaviour if size: physical_capacity = Capacity(size).roundup(6 * 64 * KiB) if pool.get_physical_capacity() != physical_capacity: if not module.check_mode: pool.update_physical_capacity(physical_capacity) changed = True if vsize: virtual_capacity = Capacity(vsize).roundup(6 * 64 * KiB) if pool.get_virtual_capacity() != virtual_capacity: if not module.check_mode: pool.update_virtual_capacity(virtual_capacity) changed = True #if pool.is_ssd_enabled() != ssd_cache: # if not module.check_mode: # pool.update_ssd_enabled(ssd_cache) # changed = True if pool.is_compression_enabled() != compression: if not module.check_mode: pool.update_compression_enabled(compression) changed = True if changed: msg = 'Pool updated' else: msg = 'Pool did not require updating' module.exit_json(changed=changed, msg=msg)
def create_volume(module, system): """Create Volume""" if not module.check_mode: if module.params['thin_provision']: prov_type = 'THIN' else: prov_type = 'THICK' pool = get_pool(module, system) volume = system.volumes.create(name=module.params['name'], provtype=prov_type, pool=pool) if module.params['size']: size = Capacity(module.params['size']).roundup(64 * KiB) volume.update_size(size) changed = True return changed
def main(): argument_spec = infinibox_argument_spec() argument_spec.update( dict(name=dict(required=True), state=dict(default='present', choices=['present', 'absent']), pool=dict(required=True), size=dict())) module = AnsibleModule(argument_spec, supports_check_mode=True) if not HAS_INFINISDK: module.fail_json(msg=missing_required_lib('infinisdk')) if not HAS_CAPACITY: module.fail_json(msg=missing_required_lib('capacity'), exception=CAPACITY_IMP_ERR) if module.params['size']: try: Capacity(module.params['size']) except Exception: module.fail_json( msg= 'size (Physical Capacity) should be defined in MB, GB, TB or PB units' ) state = module.params['state'] system = get_system(module) pool = get_pool(module, system) filesystem = get_filesystem(module, system) if pool is None: module.fail_json( msg='Pool {0} not found'.format(module.params['pool'])) if state == 'present' and not filesystem: create_filesystem(module, system) elif state == 'present' and filesystem: update_filesystem(module, filesystem) elif state == 'absent' and filesystem: delete_filesystem(module, filesystem) elif state == 'absent' and not filesystem: module.exit_json(changed=False)
def update_volume(module, volume): """Update Volume""" changed = False if module.params['size']: size = Capacity(module.params['size']).roundup(64 * KiB) if volume.get_size() != size: if not module.check_mode: volume.update_size(size) changed = True if module.params['thin_provision'] is not None: type = str(volume.get_provisioning()) if type == 'THICK' and module.params['thin_provision']: if not module.check_mode: volume.update_provisioning('THIN') changed = True if type == 'THIN' and not module.params['thin_provision']: if not module.check_mode: volume.update_provisioning('THICK') changed = True return changed
def main(): module = AnsibleModule(argument_spec=dict( name=dict(required=True), state=dict(default='present', choices=['present', 'absent']), pool=dict(required=True), size=dict(), system=dict(required=True), user=dict(no_log=True), password=dict(no_log=True), ), supports_check_mode=False) if not HAS_INFINISDK: module.fail_json(msg='infinisdk is required for this module') if module.params['size']: try: Capacity(module.params['size']) except: module.fail_json( msg= 'size (Physical Capacity) should be defined in MB, GB, TB or PB units' ) state = module.params['state'] system = get_system(module) pool = get_pool(module, system) volume = get_volume(module, system) if pool is None: module.fail_json(msg='Pool {} not found'.format(module.params['pool'])) if state == 'present' and not volume: create_volume(module, system) elif state == 'present' and volume: update_volume(module, volume) elif state == 'absent' and volume: delete_volume(module, volume) elif state == 'absent' and not volume: module.exit_json(changed=False)
def test_from_string_construction(): assert Capacity('20*GiB') == (20 * GiB)
def __init__(self, json_struct=None): self.capacityAssignedToUserView=KeyedArrayType(Capacity, 'totalSize') self.availableCapacity=Capacity() #import self.totalPotentialCapacity=Capacity() #import self.capacityInteractionAlgorithm="" super(TransferCapacityPac, self).__init__(json_struct)
def test_add(): assert (MiB + MiB) == Capacity((MiB.bits * 2)) assert (MiB + 0) == MiB assert (0 + MiB) == MiB
class Payment(object): def __init__(self, two_wheeler_price, four_wheeler_price, time): self.charge = Charge(two_wheeler_price, four_wheeler_price) self.time = time def amount(self): return self.charge.two_wheeler_price * self.time p = Payment(12, 25, 5) print(p.amount()) print(vars(p)) capacity = Capacity(10, 13) class Booking(object): _count = capacity def __init__(self, v_type, reg_number): self._vechile = Vehicle(v_type, reg_number) def __new__(cls, v_type, req_number): if v_type == 'two_wheeler': if cls._count._two_wheeler < 1: print("No space available for two wheeler sorry !!!!") else: cls._count._two_wheeler -= 1
# Input data # ========== graph_to_study = input("Choose graph to study: F1, F2 or F3? ") # Load graph # ========== filename = "data/" + graph_to_study + ".txt" edges = GraphFile(filename).read_edges_from_file() F = Graph(edges) # Get edges capacity # ================== nodes_capacity = GraphFile("data/nodes_capacity.txt").read_nodes_capacity_from_file() C = Capacity(nodes_capacity, 'i', 'f') C_edges = C.get_edges_capacity(F, "weight") for k,v in C_edges.items(): if ("i" in k) or ("f" in k): pass else: C_edges[k] = int(v) C_edges = {k:v for k,v in C_edges.items() if v > 0} # Flow Network # ============ flow_network = Graph(C_edges.copy())
from fordfulkerson import FordFulkerson import string # Load edges # ========== filename = "data/manufacturing_data.txt" edges = readwrite.read_edges_from_file(filename) G = Graph(edges) # Get edges capacity # ================== filename = "data/nodes_capacity.txt" nodes_capacity = readwrite.read_nodes_capacity_from_file(filename) C = Capacity(nodes_capacity, source_node='source', sink_node='sink') C_edges = C.get_edges_capacity(G, "weight") # Flow Network # ============ flow_network = Graph(C_edges.copy()) antiparallel_edges = flow_network.find_antiparallel_edges() counter = 0 while len(antiparallel_edges) > 0: edge = antiparallel_edges.pop(0) anti = (edge[1],edge[0]) antiparallel_edges.remove( anti ) w = flow_network.edges[anti] flow_network.deleteEdge(anti[0], anti[1])
def __init__(self, texture, capacity): self.rules = Ruler() self.texture = Texture(texture) self.capacity = Capacity(capacity)
def test_sub(): assert (MiB - bit) == Capacity((MiB.bits - 1)) assert (0 - bit) == (-bit) assert (bit - 0) == bit
def test_mul(): assert (2 * MiB) == Capacity((MiB.bits * 2)) assert (0 * MiB) == Capacity(0)
def test_from_string_fractions(): assert Capacity('1119.63 * TB') == (1119630 * GB)