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

# -*- encoding: utf-8 -*- 

# 

# Copyright © 2012 New Dream Network, LLC (DreamHost) 

# 

# 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. 

 

 

from oslo_config import cfg 

from oslo_utils import importutils 

from pecan import hooks 

 

from magnum.common import context 

from magnum.conductor import api as conductor_api 

 

 

class ContextHook(hooks.PecanHook): 

    """Configures a request context and attaches it to the request. 

 

    The following HTTP request headers are used: 

 

    X-User: 

        Used for context.user. 

 

    X-User-Id: 

        Used for context.user_id. 

 

    X-Project-Name: 

        Used for context.project. 

 

    X-Project-Id: 

        Used for context.project_id. 

 

    X-Auth-Token: 

        Used for context.auth_token. 

 

    """ 

 

    def before(self, state): 

        headers = state.request.headers 

        user = headers.get('X-User') 

        user_id = headers.get('X-User-Id') 

        project = headers.get('X-Project-Name') 

        project_id = headers.get('X-Project-Id') 

        domain_id = headers.get('X-User-Domain-Id') 

        domain_name = headers.get('X-User-Domain-Name') 

        auth_token = headers.get('X-Storage-Token') 

        auth_token = headers.get('X-Auth-Token', auth_token) 

        auth_token_info = state.request.environ.get('keystone.token_info') 

 

        auth_url = headers.get('X-Auth-Url') 

        if auth_url is None: 

            importutils.import_module('keystonemiddleware.auth_token') 

            auth_url = cfg.CONF.keystone_authtoken.auth_uri 

 

        state.request.context = context.make_context( 

            auth_token=auth_token, 

            auth_url=auth_url, 

            auth_token_info=auth_token_info, 

            user=user, 

            user_id=user_id, 

            project=project, 

            project_id=project_id, 

            domain_id=domain_id, 

            domain_name=domain_name) 

 

 

class RPCHook(hooks.PecanHook): 

    """Attach the rpcapi object to the request so controllers can get to it.""" 

 

    def before(self, state): 

        state.request.rpcapi = conductor_api.API(context=state.request.context) 

 

 

class NoExceptionTracebackHook(hooks.PecanHook): 

    """Workaround rpc.common: deserialize_remote_exception. 

    deserialize_remote_exception builds rpc exception traceback into error 

    message which is then sent to the client. Such behavior is a security 

    concern so this hook is aimed to cut-off traceback from the error message. 

    """ 

    # NOTE(max_lobur): 'after' hook used instead of 'on_error' because 

    # 'on_error' never fired for wsme+pecan pair. wsme @wsexpose decorator 

    # catches and handles all the errors, so 'on_error' dedicated for unhandled 

    # exceptions never fired. 

    def after(self, state): 

        # Omit empty body. Some errors may not have body at this level yet. 

        if not state.response.body: 

            return 

 

        # Do nothing if there is no error. 

        if 200 <= state.response.status_int < 400: 

            return 

 

        json_body = state.response.json 

        # Do not remove traceback when server in debug mode (except 'Server' 

        # errors when 'debuginfo' will be used for traces). 

        if cfg.CONF.debug and json_body.get('faultcode') != 'Server': 

            return 

 

        faultsting = json_body.get('faultstring') 

        traceback_marker = 'Traceback (most recent call last):' 

        if faultsting and (traceback_marker in faultsting): 

            # Cut-off traceback. 

            faultsting = faultsting.split(traceback_marker, 1)[0] 

            # Remove trailing newlines and spaces if any. 

            json_body['faultstring'] = faultsting.rstrip() 

            # Replace the whole json. Cannot change original one beacause it's 

            # generated on the fly. 

            state.response.json = json_body