← Back to branch summary

~raxnetworking/nova/bare_bones_melange

« back to all changes in this revision

Viewing changes to melange/db/sqlalchemy/api.py

  • Committer: Rajaram Mallya
  • Date: 2011-09-16 05:24:27 UTC
  • Revision ID: rajarammallya@gmail.com-20110916052427-gje8pj68fozcvs4d
Rajaram/Vinkesh|Striped down version of melange with only blocks and addresses

Show diffs side-by-side

added added

removed removed

Lines of Context:
melange/db/sqlalchemy/api.py
20
20
from sqlalchemy.orm import aliased
21
21
 
22
22
from melange import ipam
23
 
from melange.common import utils
24
23
from melange.db.sqlalchemy import migration
25
 
from melange.db.sqlalchemy import mappers
26
24
from melange.db.sqlalchemy import session
27
25
 
28
26
 
64
62
    _query_by(model, **conditions).update(values)
65
63
 
66
64
 
67
 
def find_inside_globals_for(local_address_id, **kwargs):
68
 
    marker_column = mappers.IpNat.inside_global_address_id
69
 
    limit = kwargs.pop('limit', 200)
70
 
    marker = kwargs.pop('marker', None)
71
 
 
72
 
    kwargs["inside_local_address_id"] = local_address_id
73
 
    query = _limits(mappers.IpNat, kwargs, limit, marker, marker_column)
74
 
    return [nat.inside_global_address for nat in query]
75
 
 
76
 
 
77
 
def find_inside_locals_for(global_address_id, **kwargs):
78
 
    marker_column = mappers.IpNat.inside_local_address_id
79
 
    limit = kwargs.pop('limit', 200)
80
 
    marker = kwargs.pop('marker', None)
81
 
 
82
 
    kwargs["inside_global_address_id"] = global_address_id
83
 
    query = _limits(mappers.IpNat, kwargs, limit, marker, marker_column)
84
 
    return [nat.inside_local_address for nat in query]
85
 
 
86
 
 
87
 
def save_nat_relationships(nat_relationships):
88
 
    for relationship in nat_relationships:
89
 
        ip_nat = mappers.IpNat()
90
 
        relationship['id'] = utils.generate_uuid()
91
 
        update(ip_nat, relationship)
92
 
        save(ip_nat)
93
 
 
94
 
 
95
 
def remove_inside_globals(local_address_id, inside_global_address=None):
96
 
 
97
 
    def _filter_inside_global_address(natted_ips, inside_global_address):
98
 
        return natted_ips.join((ipam.models.IpAddress,
99
 
         mappers.IpNat.inside_global_address_id == ipam.models.IpAddress.id)).\
100
 
         filter(ipam.models.IpAddress.address == inside_global_address)
101
 
 
102
 
    _remove_natted_ips(_filter_inside_global_address,
103
 
                      inside_global_address,
104
 
                      inside_local_address_id=local_address_id)
105
 
 
106
 
 
107
 
def remove_inside_locals(global_address_id, inside_local_address=None):
108
 
 
109
 
    def _filter_inside_local_address(natted_ips, inside_local_address):
110
 
        return natted_ips.join((ipam.models.IpAddress,
111
 
          mappers.IpNat.inside_local_address_id == ipam.models.IpAddress.id)).\
112
 
          filter(ipam.models.IpAddress.address == inside_local_address)
113
 
 
114
 
    _remove_natted_ips(_filter_inside_local_address,
115
 
                      inside_local_address,
116
 
                      inside_global_address_id=global_address_id)
117
 
 
118
 
 
119
 
def _remove_natted_ips(filter_by_natted_address_func,
120
 
                       natted_address, **kwargs):
121
 
    natted_ips = find_natted_ips(**kwargs)
122
 
    if natted_address != None:
123
 
        natted_ips = filter_by_natted_address_func(natted_ips, natted_address)
124
 
    for ip in natted_ips:
125
 
        delete(ip)
126
 
 
127
 
 
128
 
def find_natted_ips(**kwargs):
129
 
    return _base_query(mappers.IpNat).filter_by(**kwargs)
130
 
 
131
 
 
132
65
def find_all_blocks_with_deallocated_ips():
133
66
    return _base_query(ipam.models.IpBlock).\
134
67
           join(ipam.models.IpAddress).\
135
68
           filter(ipam.models.IpAddress.marked_for_deallocation == True)
136
69
 
137
70
 
138
 
def delete_deallocated_ips(deallocated_by, **kwargs):
139
 
    return _delete_all(_query_by(ipam.models.IpAddress, **kwargs).\
140
 
           filter_by(marked_for_deallocation=True).\
141
 
           filter(ipam.models.IpAddress.deallocated_at <= deallocated_by))
142
 
 
143
 
 
144
 
def find_all_top_level_blocks_in_network(network_id):
145
 
    parent_block = aliased(ipam.models.IpBlock, name="parent_block")
146
 
 
147
 
    return _base_query(ipam.models.IpBlock).\
148
 
        outerjoin((parent_block,
149
 
                   and_(ipam.models.IpBlock.parent_id == parent_block.id,
150
 
                        parent_block.network_id == network_id))).\
151
 
        filter(ipam.models.IpBlock.network_id == network_id).\
152
 
        filter(parent_block.id == None)
153
 
 
154
 
 
155
71
def find_all_ips_in_network(network_id, **conditions):
156
72
    return _query_by(ipam.models.IpAddress, **conditions).\
157
73
           join(ipam.models.IpBlock).\