Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

# Copyright 2014 Red Hat, Inc. 

# All Rights Reserved. 

# 

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

#    not use this file except in compliance with the License. You may obtain 

#    a copy of the License at 

# 

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

# 

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

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

#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 

#    License for the specific language governing permissions and limitations 

#    under the License. 

 

__all__ = [ 

    'init', 

    'cleanup', 

    'set_defaults', 

    'add_extra_exmods', 

    'clear_extra_exmods', 

    'get_allowed_exmods', 

    'RequestContextSerializer', 

    'get_client', 

    'get_server', 

    'get_notifier', 

    'TRANSPORT_ALIASES', 

] 

 

from oslo_config import cfg 

import oslo_messaging as messaging 

from oslo_serialization import jsonutils 

 

from magnum.common import context as magnum_context 

from magnum.common import exception 

 

 

CONF = cfg.CONF 

TRANSPORT = None 

NOTIFIER = None 

 

ALLOWED_EXMODS = [ 

    exception.__name__, 

] 

EXTRA_EXMODS = [] 

 

# NOTE(lucasagomes): The magnum.openstack.common.rpc entries are for 

# backwards compat with IceHouse rpc_backend configuration values. 

TRANSPORT_ALIASES = { 

    'magnum.openstack.common.rpc.impl_kombu': 'rabbit', 

    'magnum.openstack.common.rpc.impl_qpid': 'qpid', 

    'magnum.openstack.common.rpc.impl_zmq': 'zmq', 

    'magnum.rpc.impl_kombu': 'rabbit', 

    'magnum.rpc.impl_qpid': 'qpid', 

    'magnum.rpc.impl_zmq': 'zmq', 

} 

 

 

def init(conf): 

    global TRANSPORT, NOTIFIER 

    exmods = get_allowed_exmods() 

    TRANSPORT = messaging.get_transport(conf, 

                                        allowed_remote_exmods=exmods, 

                                        aliases=TRANSPORT_ALIASES) 

    serializer = RequestContextSerializer(JsonPayloadSerializer()) 

    NOTIFIER = messaging.Notifier(TRANSPORT, serializer=serializer) 

 

 

def cleanup(): 

    global TRANSPORT, NOTIFIER 

    assert TRANSPORT is not None 

    assert NOTIFIER is not None 

    TRANSPORT.cleanup() 

    TRANSPORT = NOTIFIER = None 

 

 

def set_defaults(control_exchange): 

    messaging.set_transport_defaults(control_exchange) 

 

 

def add_extra_exmods(*args): 

    EXTRA_EXMODS.extend(args) 

 

 

def clear_extra_exmods(): 

    del EXTRA_EXMODS[:] 

 

 

def get_allowed_exmods(): 

    return ALLOWED_EXMODS + EXTRA_EXMODS 

 

 

class JsonPayloadSerializer(messaging.NoOpSerializer): 

    @staticmethod 

    def serialize_entity(context, entity): 

        return jsonutils.to_primitive(entity, convert_instances=True) 

 

 

class RequestContextSerializer(messaging.Serializer): 

 

    def __init__(self, base): 

        self._base = base 

 

    def serialize_entity(self, context, entity): 

        if not self._base: 

            return entity 

        return self._base.serialize_entity(context, entity) 

 

    def deserialize_entity(self, context, entity): 

        if not self._base: 

            return entity 

        return self._base.deserialize_entity(context, entity) 

 

    def serialize_context(self, context): 

        return context 

 

    def deserialize_context(self, context): 

        return magnum_context.RequestContext.from_dict(context) 

 

 

def get_transport_url(url_str=None): 

    return messaging.TransportURL.parse(CONF, url_str, TRANSPORT_ALIASES) 

 

 

def get_client(target, version_cap=None, serializer=None): 

    assert TRANSPORT is not None 

    serializer = RequestContextSerializer(serializer) 

    return messaging.RPCClient(TRANSPORT, 

                               target, 

                               version_cap=version_cap, 

                               serializer=serializer) 

 

 

def get_server(target, endpoints, serializer=None): 

    assert TRANSPORT is not None 

    serializer = RequestContextSerializer(serializer) 

    return messaging.get_rpc_server(TRANSPORT, 

                                    target, 

                                    endpoints, 

                                    executor='eventlet', 

                                    serializer=serializer) 

 

 

def get_notifier(service=None, host=None, publisher_id=None): 

    assert NOTIFIER is not None 

    if not publisher_id: 

        publisher_id = "%s.%s" % (service, host or CONF.host) 

    return NOTIFIER.prepare(publisher_id=publisher_id)