def pcef_create_session(args):
chan = ServiceRegistry.get_rpc_channel(args.pcef, ServiceRegistry.LOCAL)
client = LocalSessionManagerStub(chan)
request = LocalCreateSessionRequest(
sid=SIDUtils.to_pb(args.imsi),
ue_ipv4=args.user_ip)
client.CreateSession(request)
def send_create_session(client, args):
sub1 = SubContextConfig('IMSI' + args.imsi, '192.168.128.74', 4)
try:
create_account_in_PCRF(args.imsi)
except grpc.RpcError as e:
print("gRPC failed with %s: %s" % (e.code(), e.details()))
try:
create_account_in_OCS(args.imsi)
except grpc.RpcError as e:
print("gRPC failed with %s: %s" % (e.code(), e.details()))
req = LocalCreateSessionRequest(
sid=SubscriberID(id=sub1.imsi),
ue_ipv4=sub1.ip,
)
print("Sending LocalCreateSessionRequest with following fields:\n %s" %
req)
try:
client.CreateSession(req)
except grpc.RpcError as e:
print("gRPC failed with %s: %s" % (e.code(), e.details()))
req = SubscriberID(id=sub1.imsi)
print("Sending EndSession with following fields:\n %s" % req)
try:
client.EndSession(req)
except grpc.RpcError as e:
print("gRPC failed with %s: %s" % (e.code(), e.details()))
def _build_create_session_data(subs: List[SubscriberID]):
reqs = []
for sid in subs:
# build request
req = LocalCreateSessionRequest(
common_context=CommonSessionContext(
sid=sid,
apn=TEST_APN,
rat_type=TGPP_LTE,
),
rat_specific_context=RatSpecificContext(
lte_context=LTESessionContext(bearer_id=1, ), ),
)
req_dict = json_format.MessageToDict(req)
# Dumping AllocateIP request into json
reqs.append(req_dict)
with open(CREATE_SESSION_FILENAME, 'w') as file:
json.dump(reqs, file, separators=(',', ':'))
def test_reauth(self):
"""
Send a Gx reauth request which installs one new static rule, one new
dynamic rule, and removes one static and one dynamic rule.
"""
dynamic_rule1 = create_uplink_rule('dynamic1',
1,
'46.10.10.1',
tracking=PolicyRule.NO_TRACKING)
dynamic_rule2 = create_uplink_rule('dynamic2',
1,
'46.10.10.2',
tracking=PolicyRule.NO_TRACKING)
# Initialize sub with 1 static and 1 dynamic rule
sub = SubContextConfig('IMSI001010000088888', '192.168.128.74',
default_ambr_config, 4)
self.test_util.controller.mock_create_session = Mock(
return_value=CreateSessionResponse(
credits=[create_update_response(sub.imsi, 1, 1024)],
static_rules=[
session_manager_pb2.StaticRuleInstall(rule_id='policy1')
],
dynamic_rules=[
session_manager_pb2.DynamicRuleInstall(
policy_rule=dynamic_rule1)
],
usage_monitors=[],
), )
self.test_util.controller.mock_terminate_session = Mock(
return_value=SessionTerminateResponse(), )
self.test_util.sessiond.CreateSession(
LocalCreateSessionRequest(
sid=SubscriberID(id=sub.imsi),
ue_ipv4=sub.ip,
))
self.assertEqual(
self.test_util.controller.mock_create_session.call_count,
1,
)
# first, send some packets so we know that the uplink rules are
# accepting traffic
self._assert_rules(
sub,
[
session_manager_pb2.DynamicRuleInstall(
policy_rule=self.test_util.static_rules['policy1']),
session_manager_pb2.DynamicRuleInstall(
policy_rule=dynamic_rule1)
],
)
# Now via reauth, remove the old rules and install new uplink rules
# Verify the new uplink rules allow traffic
reauth_result = self.test_util.proxy_responder.PolicyReAuth(
PolicyReAuthRequest(
imsi=sub.imsi,
rules_to_remove=['dynamic1', 'policy1'],
rules_to_install=[
session_manager_pb2.StaticRuleInstall(rule_id='policy2')
],
dynamic_rules_to_install=[
session_manager_pb2.DynamicRuleInstall(
policy_rule=dynamic_rule2)
],
))
self.assertEqual(
reauth_result.result,
session_manager_pb2.UPDATE_INITIATED,
)
self.assertEqual(len(reauth_result.failed_rules), 0)
self._assert_rules(
sub,
[
session_manager_pb2.DynamicRuleInstall(
policy_rule=self.test_util.static_rules['policy2']),
session_manager_pb2.DynamicRuleInstall(
policy_rule=dynamic_rule2)
],
)
# Verify the old rules no longer allow traffic (uninstalled)
self._assert_rules(
sub,
[
session_manager_pb2.DynamicRuleInstall(
policy_rule=self.test_util.static_rules['policy1']),
session_manager_pb2.DynamicRuleInstall(
policy_rule=dynamic_rule1)
],
expected=0,
)