gerrit.onap Code Review - dcaegen2/services.git/blob - components/pm-subscription-handler/pmsh_service/mod/api/db

1 # ============LICENSE_START===================================================

3 # ============================================================================

4 # Licensed under the Apache License, Version 2.0 (the "License");

5 # you may not use this file except in compliance with the License.

6 # You may obtain a copy of the License at

7 #

8 # http://www.apache.org/licenses/LICENSE-2.0

9 #

10 # Unless required by applicable law or agreed to in writing, software

11 # distributed under the License is distributed on an "AS IS" BASIS,

12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

13 # See the License for the specific language governing permissions and

14 # limitations under the License.

15 #

16 # SPDX-License-Identifier: Apache-2.0

17 # ============LICENSE_END=====================================================

18

19 from sqlalchemy import Column, Integer, String, ForeignKey, JSON

20 from sqlalchemy.orm import relationship

21

22 from mod import db

23

24

25 class SubscriptionModel(db.Model):

26 __tablename__ = 'subscriptions'

27 id = Column(Integer, primary_key=True, autoincrement=True)

28 subscription_name = Column(String(100), unique=True)

29 status = Column(String(20))

30

31 nfs = relationship(

32 'NfSubRelationalModel',

33 cascade='all, delete-orphan',

34 backref='subscription')

35

36 network_filter = relationship(

37 'NetworkFunctionFilterModel',

38 cascade='all, delete-orphan',

39 backref='subscription')

40

41 measurement_groups = relationship(

42 'MeasurementGroupModel',

43 cascade='all, delete-orphan',

44 backref='subscription')

45

46 def __init__(self, subscription_name, status):

47 self.subscription_name = subscription_name

48 self.status = status

49

50 def __repr__(self):

51 return f'subscription_name: {self.subscription_name}, status: {self.status}'

52

53 def __eq__(self, other):

54 if isinstance(self, other.__class__):

55 return self.subscription_name == other.subscription_name

56 return False

57

58 def serialize(self):

59 sub_nfs = NfSubRelationalModel.query.filter(

60 NfSubRelationalModel.subscription_name == self.subscription_name).all()

61 db.session.remove()

62 return {'subscription_name': self.subscription_name, 'subscription_status': self.status,

63 'network_functions': [sub_nf.serialize_nf() for sub_nf in sub_nfs]}

64

65

66 class NetworkFunctionModel(db.Model):

67 __tablename__ = 'network_functions'

68 id = Column(Integer, primary_key=True, autoincrement=True)

69 nf_name = Column(String(100), unique=True)

70 ipv4_address = Column(String(50))

71 ipv6_address = Column(String(50))

72 model_invariant_id = Column(String(100))

73 model_version_id = Column(String(100))

74 model_name = Column(String(100))

75 sdnc_model_name = Column(String(100))

76 sdnc_model_version = Column(String(100))

77 retry_count = Column(Integer)

78

79 subscriptions = relationship(

80 'NfSubRelationalModel',

81 cascade='all, delete-orphan',

82 backref='nf')

83

84 def __init__(self, nf_name, ipv4_address, ipv6_address, model_invariant_id,

85 model_version_id, model_name, sdnc_model_name,

86 sdnc_model_version, retry_count=0):

87 self.nf_name = nf_name

88 self.ipv4_address = ipv4_address

89 self.ipv6_address = ipv6_address

90 self.model_invariant_id = model_invariant_id

91 self.model_version_id = model_version_id

92 self.model_name = model_name

93 self.sdnc_model_name = sdnc_model_name

94 self.sdnc_model_version = sdnc_model_version

95 self.retry_count = retry_count

96

97 def __repr__(self):

98 return str(self.to_nf())

99

100 def to_nf(self):

101 from mod.network_function import NetworkFunction

102 return NetworkFunction(sdnc_model_name=self.sdnc_model_name,

103 sdnc_model_version=self.sdnc_model_version,

104 **{'nf_name': self.nf_name,

105 'ipv4_address': self.ipv4_address,

106 'ipv6_address': self.ipv6_address,

107 'model_invariant_id': self.model_invariant_id,

108 'model_version_id': self.model_version_id})

109

110

111 class NfSubRelationalModel(db.Model):

112 __tablename__ = 'nf_to_sub_rel'

113 __mapper_args__ = {

114 'confirm_deleted_rows': False

115 }

116 id = Column(Integer, primary_key=True, autoincrement=True)

117 subscription_name = Column(

118 String,

119 ForeignKey(SubscriptionModel.subscription_name, ondelete='cascade', onupdate='cascade')

120 )

121 nf_name = Column(

122 String,

123 ForeignKey(NetworkFunctionModel.nf_name, ondelete='cascade', onupdate='cascade')

124 )

125 nf_sub_status = Column(String(20))

126

127 def __init__(self, subscription_name, nf_name, nf_sub_status=None):

128 self.subscription_name = subscription_name

129 self.nf_name = nf_name

130 self.nf_sub_status = nf_sub_status

131

132 def __repr__(self):

133 return f'subscription_name: {self.subscription_name}, ' \

134 f'nf_name: {self.nf_name}, nf_sub_status: {self.nf_sub_status}'

135

136 def serialize(self):

137 return {'subscription_name': self.subscription_name, 'nf_name': self.nf_name,

138 'nf_sub_status': self.nf_sub_status}

139

140 def serialize_nf(self):

141 nf = NetworkFunctionModel.query.filter(

142 NetworkFunctionModel.nf_name == self.nf_name).one_or_none()

143 db.session.remove()

144 return {'nf_name': self.nf_name,

145 'ipv4_address': nf.ipv4_address,

146 'ipv6_address': nf.ipv6_address,

147 'nf_sub_status': self.nf_sub_status,

148 'model_invariant_id': nf.model_invariant_id,

149 'model_version_id': nf.model_version_id,

150 'model_name': nf.model_name,

151 'sdnc_model_name': nf.sdnc_model_name,

152 'sdnc_model_version': nf.sdnc_model_version}

153

154

155 class NetworkFunctionFilterModel(db.Model):

156 __tablename__ = 'nf_filter'

157 id = Column(Integer, primary_key=True, autoincrement=True)

158 subscription_name = Column(

159 String,

160 ForeignKey(SubscriptionModel.subscription_name, ondelete='cascade', onupdate='cascade'),

161 unique=True

162 )

163 nf_names = Column(String(100))

164 model_invariant_ids = Column(String(100))

165 model_version_ids = Column(String(100))

166 model_names = Column(String(100))

167

168 def __init__(self, subscription_name, nf_names, model_invariant_ids, model_version_ids,

169 model_names):

170 self.subscription_name = subscription_name

171 self.nf_names = nf_names

172 self.model_invariant_ids = model_invariant_ids

173 self.model_version_ids = model_version_ids

174 self.model_names = model_names

175

176 def __repr__(self):

177 return f'subscription_name: {self.subscription_name}, ' \

178 f'nf_names: {self.nf_names}, model_invariant_ids: {self.model_invariant_ids}' \

179 f'model_version_ids: {self.model_version_ids}, model_names: {self.model_names}'

180

181 def serialize(self):

182 return {'subscription_name': self.subscription_name, 'nf_names': self.nf_names,

183 'model_invariant_ids': self.model_invariant_ids,

184 'model_version_ids': self.model_version_ids, 'model_names': self.model_names}

185

186

187 class MeasurementGroupModel(db.Model):

188 __tablename__ = 'measurement_group'

189 id = Column(Integer, primary_key=True, autoincrement=True)

190 subscription_name = Column(

191 String,

192 ForeignKey(SubscriptionModel.subscription_name, ondelete='cascade', onupdate='cascade')

193 )

194 measurement_group_name = Column(String(100), unique=True)

195 administrative_state = Column(String(20))

196 file_based_gp = Column(Integer)

197 file_location = Column(String(100))

198 measurement_type = Column(JSON)

199 managed_object_dns_basic = Column(JSON)

200

201 def __init__(self, subscription_name, measurement_group_name,

202 administrative_state, file_based_gp, file_location,

203 measurement_type, managed_object_dns_basic):

204 self.subscription_name = subscription_name

205 self.measurement_group_name = measurement_group_name

206 self.administrative_state = administrative_state

207 self.file_based_gp = file_based_gp

208 self.file_location = file_location

209 self.measurement_type = measurement_type

210 self.managed_object_dns_basic = managed_object_dns_basic

211

212 def __repr__(self):

213 return f'subscription_name: {self.subscription_name}, ' \

214 f'measurement_group_name: {self.measurement_group_name},' \

215 f'administrative_state: {self.administrative_state},' \

216 f'file_based_gp: {self.file_based_gp},' \

217 f'file_location: {self.file_location},' \

218 f'measurement_type: {self.measurement_type}' \

219 f'managed_object_dns_basic: {self.managed_object_dns_basic}'

220

221 def serialize(self):

222 return {'subscription_name': self.subscription_name,

223 'measurement_group_name': self.measurement_group_name,

224 'administrative_state': self.administrative_state,

225 'file_based_gp': self.file_based_gp,

226 'file_location': self.file_location,

227 'measurement_type': self.measurement_type,

228 'managed_object_dns_basic': self.managed_object_dns_basic}

229

230

231 class NfMeasureGroupRelationalModel(db.Model):

232 __tablename__ = 'nf_to_measure_grp_rel'

233 __mapper_args__ = {

234 'confirm_deleted_rows': False

235 }

236 id = Column(Integer, primary_key=True, autoincrement=True)

237 measurement_grp_name = Column(

238 String,

239 ForeignKey(MeasurementGroupModel.measurement_group_name, ondelete='cascade',

240 onupdate='cascade')

241 )

242 nf_name = Column(

243 String,

244 ForeignKey(NetworkFunctionModel.nf_name, ondelete='cascade', onupdate='cascade')

245 )

246 nf_measure_grp_status = Column(String(20))

247 retry_count = Column(Integer)

248

249 def __init__(self, measurement_grp_name, nf_name, nf_measure_grp_status=None,

250 retry_count=0):

251 self.measurement_grp_name = measurement_grp_name

252 self.nf_name = nf_name

253 self.nf_measure_grp_status = nf_measure_grp_status

254 self.retry_count = retry_count

255

256 def __repr__(self):

257 return f'measurement_grp_name: {self.measurement_grp_name}, ' \

258 f'nf_name: {self.nf_name}, nf_measure_grp_status: {self.nf_measure_grp_status}'