Source Code for Module backend.upload_server.handlers.package_push.package_push

  1  # 
  2  # Code that drops files on the filesystem (/PKG-UPLOAD) 
  3  # 
  4  # 
  5  # Copyright (c) 2008--2017 Red Hat, Inc. 
  6  # 
  7  # This software is licensed to you under the GNU General Public License, 
  8  # version 2 (GPLv2). There is NO WARRANTY for this software, express or 
  9  # implied, including the implied warranties of MERCHANTABILITY or FITNESS 
 10  # FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2 
 11  # along with this software; if not, see 
 12  # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. 
 13  # 
 14  # Red Hat trademarks are not licensed under GPLv2. No permission is 
 15  # granted to use or replicate Red Hat trademarks that are incorporated 
 16  # in this software or its documentation. 
 17  # 
 18  # 
 19   
 20  import os 
 21  import base64 
 22  import sys 
 23  from rhn import rpclib 
 24   
 25  from spacewalk.common import apache, rhnFlags 
 26  from spacewalk.common.rhnLog import log_debug, log_error 
 27  from spacewalk.common.rhnConfig import CFG 
 28  from spacewalk.common.rhnException import rhnFault 
 29  from spacewalk.server.importlib.importLib import InvalidArchError 
 30  from spacewalk.server import rhnPackageUpload, rhnSQL, basePackageUpload 
 31   
 32   
 33 -class PackagePush(basePackageUpload.BasePackageUpload): 
 34   
 35 -    def __init__(self, req): 
 36          basePackageUpload.BasePackageUpload.__init__(self, req) 
 37          self.required_fields.extend([ 
 38              'Auth', 
 39              'Force', 
 40          ]) 
 41          self.null_org = None 
 42          # Default packaging is rpm 
 43          self.packaging = 'rpm' 
 44          self.username = None 
 45          self.password = None 
 46          self.force = None 
 47          self.rel_package_path = None 
 48          self.org_id = None 
 49          self.package_path = None 
 50   
 51 -    def headerParserHandler(self, req): 
 52          ret = basePackageUpload.BasePackageUpload.headerParserHandler(self, req) 
 53          # Optional headers 
 54          maps = [['Null-Org', 'null_org'], ['Packaging', 'packaging']] 
 55          for hn, sn in maps: 
 56              header_name = "%s-%s" % (self.header_prefix, hn) 
 57              if header_name in req.headers_in: 
 58                  setattr(self, sn, req.headers_in[header_name]) 
 59   
 60          if ret != apache.OK: 
 61              return ret 
 62   
 63          if CFG.SEND_MESSAGE_TO_ALL: 
 64              rhnSQL.closeDB() 
 65              log_debug(1, "send_message_to_all is set") 
 66   
 67              rhnFlags.set("apache-return-code", apache.HTTP_NOT_FOUND) 
 68              try: 
 69                  outage_message = open(CFG.MESSAGE_TO_ALL).read() 
 70              except IOError: 
 71                  log_error("Missing outage message file") 
 72                  outage_message = "Outage mode" 
 73              raise rhnFault(20001, outage_message, explain=0) 
 74   
 75          # Init the database connection 
 76          rhnSQL.initDB() 
 77          use_session = 0 
 78          if self.field_data.has_key('Auth-Session'): 
 79              session_token = self.field_data['Auth-Session'] 
 80              use_session = 1 
 81          else: 
 82              encoded_auth_token = self.field_data['Auth'] 
 83   
 84          if not use_session: 
 85              auth_token = self.get_auth_token(encoded_auth_token) 
 86   
 87              if len(auth_token) < 2: 
 88                  log_debug(3, auth_token) 
 89                  raise rhnFault(105, "Unable to autenticate") 
 90   
 91              self.username, self.password = auth_token[:2] 
 92   
 93          force = self.field_data['Force'] 
 94          force = int(force) 
 95          log_debug(1, "Username", self.username, "Force", force) 
 96   
 97          if use_session: 
 98              self.org_id, self.force = rhnPackageUpload.authenticate_session(session_token, 
 99                                                                              force=force, null_org=self.null_org) 
100          else: 
101              # We don't push to any channels 
102              self.org_id, self.force = rhnPackageUpload.authenticate(self.username, 
103                                                                      self.password, force=force, null_org=self.null_org) 
104   
105          return apache.OK 
106   
107 -    def handler(self, req): 
108          ret = basePackageUpload.BasePackageUpload.handler(self, req) 
109          if ret != apache.OK: 
110              return ret 
111   
112          a_pkg = rhnPackageUpload.save_uploaded_package(req, 
113                                                         (self.package_name, None, self.package_version, 
114                                                          self.package_release, self.package_arch), 
115                                                         str(self.org_id), 
116                                                         self.packaging, 
117                                                         self.file_checksum_type, self.file_checksum) 
118   
119          self.rel_package_path = rhnPackageUpload.relative_path_from_header( 
120              a_pkg.header, org_id=self.org_id, 
121              checksum_type=a_pkg.checksum_type, checksum=a_pkg.checksum) 
122          self.package_path = os.path.join(CFG.MOUNT_POINT, 
123                                           self.rel_package_path) 
124   
125          try: 
126              package_dict, diff_level = rhnPackageUpload.push_package(a_pkg, 
127                                                                       force=self.force, 
128                                                                       relative_path=self.rel_package_path, 
129                                                                       org_id=self.org_id) 
130          except InvalidArchError: 
131              e = sys.exc_info()[1] 
132              req.write(str(e)) 
133              return apache.HTTP_NOT_ACCEPTABLE 
134          except Exception: 
135              e = sys.exc_info()[1] 
136              req.write(str(e)) 
137              return apache.HTTP_BAD_REQUEST 
138   
139          if diff_level: 
140              return self._send_package_diff(req, diff_level, package_dict) 
141   
142          # Everything went fine 
143          rhnSQL.commit() 
144          reply = "All OK" 
145          req.headers_out['Content-Length'] = str(len(reply)) 
146          req.send_http_header() 
147          req.write(reply) 
148          log_debug(2, "Returning with OK") 
149   
150          return apache.OK 
151   
152      @staticmethod 
153 -    def _send_package_diff(req, diff_level, diff): 
154          args = { 
155              'level': diff_level, 
156              'diff': diff, 
157          } 
158          reply = rpclib.xmlrpclib.dumps((args, )) 
159          ret_stat = apache.HTTP_BAD_REQUEST 
160          req.status = ret_stat 
161          req.err_headers_out['Content-Length'] = str(len(reply)) 
162          req.send_http_header() 
163          req.write(reply) 
164          return apache.OK 
165   
166      @staticmethod 
167 -    def get_auth_token(value): 
168          s = ''.join([x.strip() for x in value.split(',')]) 
169          arr = list(map(base64.decodestring, s.split(':'))) 
170          return arr 
171