Exemple #1
0
    def run(self, options):
        logs.begin(
            saveLog=stampedAPI._logsDB.saveLog,
            saveStat=stampedAPI._statsDB.addStat,
            nodeName=stampedAPI.node_name
        )
        logs.async_request('alerts')

        lock = os.path.join(base, 'alerts.lock')
        if os.path.exists(lock):
            logs.warning('Locked - aborting')
            return
        
        try:
            open(lock, 'w').close()
            self.buildAlerts(limit=options.limit, noop=options.noop)
            self.buildInvitations(limit=options.limit, noop=options.noop)
            if len(self._emailQueue) > 0:
                self.sendEmails(noop=options.noop)
            if len(self._pushQueue) > 0:
                self.sendPush(noop=options.noop)
            self.cleanupPush(noop=options.noop)

        except Exception as e:
            logs.warning('Exception: %s' % e)
            logs.warning(utils.getFormattedException())
            logs.error(500)

        finally:
            os.remove(lock)
            try:
                logs.save()
            except Exception:
                print '\n\n\nWARNING: UNABLE TO SAVE LOGS\n\n\n'
Exemple #2
0
def passwordReset(request, **kwargs):
    token  = kwargs.pop('token', None)

    errorMsg = 'An error occurred. Please try again.'

    try:
        # Verify token is valid
        authUserId = stampedAuth.verifyPasswordResetToken(token)

        # Check if a form exists with data
        if request.method == 'POST':
            # User submitted the form
            data = request.POST

            # Verify passwords match and len > 0
            if not data['password']:
                logs.warning("Invalid password: %s" % data['password'])
                raise StampedInvalidPasswordError("Invalid password")

            if data['password'] != data['confirm']:
                logs.warning("Password match failed")
                raise StampedInvalidPasswordError("Password match failed")
            
            # Store password            
            stampedAuth.updatePassword(authUserId, data['password'])

            # Return success
            response = HttpResponseRedirect('/settings/password/success')

        else:
            # Display 'change password' form
            account = stampedAPI.getAccount(authUserId)
            params = {
                'token': token,
                'form': True,
                }
            response = render_to_response('password-reset.html', params)

        return response

    except Exception as e:
        logs.begin(
            addLog=stampedAPI._logsDB.addLog, 
            saveLog=stampedAPI._logsDB.saveLog,
            saveStat=stampedAPI._statsDB.addStat,
            requestData=request,
        )
        logs.request(request)
        logs.warning("500 Error: %s" % e)
        logs.error(500)
        logs.save()

        return render_to_response('password-reset.html', {'error': errorMsg})
Exemple #3
0
 def _wrapper(request, *args, **kwargs):
     import servers.web2.error.views as web_error
     
     try:
         logs.begin(saveLog=stampedAPIProxy.api._logsDB.saveLog,
                    saveStat=stampedAPIProxy.api._statsDB.addStat,
                    requestData=request,
                    nodeName=stampedAPIProxy.api.node_name)
         logs.info("%s %s" % (request.method, request.path))
         
         subkwargs = kwargs
         
         if schema is not None:
             parse_kwargs  = parse_request_kwargs or {}
             django_kwargs = {}
             
             if parse_django_kwargs:
                 django_kwargs = kwargs or {}
                 subkwargs = {}
             
             result = parse_request(request, schema(), django_kwargs, overflow=ignore_extra_params, **parse_kwargs)
             subkwargs['schema'] = result
         
         response = fn(request, *args, **subkwargs)
         logs.info("End request: Success")
         
         if no_cache:
             expires = (dt.datetime.utcnow() - dt.timedelta(minutes=10)).ctime()
             cache_control = 'no-cache'
         elif utils.is_ec2():
             expires = (dt.datetime.utcnow() + dt.timedelta(minutes=60)).ctime()
             cache_control = 'max-age=600'
         else:
             # disable caching for local development / debugging
             expires = (dt.datetime.utcnow() - dt.timedelta(minutes=10)).ctime()
             cache_control = 'max-age=0'
         
         response['Expires'] = expires
         response['Cache-Control'] = cache_control
         
         return response
     
     except urllib2.HTTPError, e:
         logs.warning("%s Error: %s" % (e.code, e))
         logs.warning(utils.getFormattedException())
         
         if e.code == 404:
             return web_error.error_404(request)
         elif e.code >= 500:
             return web_error.error_500(request)
         
         raise # invoke django's default 500 handler
Exemple #4
0
def passwordForgot(request):

    errorMsg = 'An error occurred. Please try again.'

    try:
        # Check if a form exists with data
        if request.method == 'POST':
            # User submitted the form
            data = request.POST

            # Validate email address
            email = str(data['forgotemail']).lower().strip()
            if not utils.validate_email(email):
                msg = "Invalid format for email address"
                logs.warning(msg)
                raise StampedInvalidEmailError("Invalid email address")
            
            # Verify account exists
            try:
                user = stampedAPI.checkAccount(email)
            except:
                ### TODO: Display appropriate error message
                errorMsg = 'No account information was found for that email address.'
                raise StampedHTTPError(404, msg="Email address not found", kind='invalid_input')

            # Send email
            stampedAuth.forgotPassword(email)

            # Return success
            response = HttpResponseRedirect('/settings/password/sent')

        else:
            # Display 'submit email' form
            response = render_to_response('password-forgot.html', None)

        return response

    except Exception as e:
        logs.begin(
            addLog=stampedAPI._logsDB.addLog, 
            saveLog=stampedAPI._logsDB.saveLog,
            saveStat=stampedAPI._statsDB.addStat,
            requestData=request,
        )
        logs.request(request)
        logs.warning("500 Error: %s" % e)
        logs.error(500)
        logs.save()

        return render_to_response('password-forgot.html', {'error': errorMsg})

    return True
Exemple #5
0
def alertSettings(request, **kwargs):
    try:
        # Check token
        tokenId     = request.GET.get('token', None)
        authUserId  = stampedAuth.verifyEmailAlertToken(tokenId)

        # Display 'change settings' form
        account = stampedAPI.getAccount(authUserId)

        alerts  = HTTPAccountAlerts().importSchema(account)
        user    = HTTPUser().importSchema(account)

        image_url = user['image_url'].replace('.jpg', '-31x31.jpg')
        stamp_url = 'http://static.stamped.com/logos/%s-%s-credit-18x18.png' % \
                    (user.color_primary, user.color_secondary)

        settings = {
            'email_alert_credit':   alerts.email_alert_credit,
            'email_alert_like':     alerts.email_alert_like,
            'email_alert_fav':      alerts.email_alert_fav,
            'email_alert_mention':  alerts.email_alert_mention,
            'email_alert_comment':  alerts.email_alert_comment,
            'email_alert_reply':    alerts.email_alert_reply,
            'email_alert_follow':   alerts.email_alert_follow,
        }

        params = {
            'screen_name':      user.screen_name,
            'name':             user.name,
            'image_url':        image_url,
            'stamp_url':        stamp_url,
            'action_token':     tokenId,
            'json_settings':    json.dumps(settings, sort_keys=True)
        }
        
        return render_to_response('notifications.html', params)

    except Exception as e:
        logs.begin(
            addLog=stampedAPI._logsDB.addLog, 
            saveLog=stampedAPI._logsDB.saveLog,
            saveStat=stampedAPI._statsDB.addStat,
            requestData=request,
        )
        logs.request(request)
        logs.warning("500 Error: %s" % e)
        logs.error(500)
        logs.save()

        ### TODO: CHANGE URL
        return render_to_response('password-reset.html', {'error': 'FAIL'})
Exemple #6
0
def alertSettingsUpdate(request, **kwargs):
    try:
        # Check token
        tokenId     = request.POST.get('token', None)
        authUserId  = stampedAuth.verifyEmailAlertToken(tokenId)

        def _checkBool(v):
            if v in ['True', 'true', '1', 1, True]:
                return True
            return False

        # Get settings
        alerts = {
            'email_alert_credit':   _checkBool(request.POST.get('email_alert_credit', False)),
            'email_alert_like':     _checkBool(request.POST.get('email_alert_like', False)),
            'email_alert_fav':      _checkBool(request.POST.get('email_alert_fav', False)),
            'email_alert_mention':  _checkBool(request.POST.get('email_alert_mention', False)),
            'email_alert_comment':  _checkBool(request.POST.get('email_alert_comment', False)),
            'email_alert_reply':    _checkBool(request.POST.get('email_alert_reply', False)),
            'email_alert_follow':   _checkBool(request.POST.get('email_alert_follow', False)),
        }

        stampedAPI.updateAlerts(authUserId, alerts)
        
        params = {}
        params.setdefault('content_type', 'text/javascript; charset=UTF-8')
        params.setdefault('mimetype', 'application/json')
        
        output_json = json.dumps(alerts, sort_keys=True)
        output = HttpResponse(output_json, **params)
        
        return output
    
    except Exception as e:
        logs.begin(
            addLog=stampedAPI._logsDB.addLog, 
            saveLog=stampedAPI._logsDB.saveLog,
            saveStat=stampedAPI._statsDB.addStat,
            requestData=request,
        )
        logs.request(request)
        logs.warning("500 Error: %s" % e)
        logs.error(500)
        logs.save()
        
        return HttpResponse("internal server error", status=500)
Exemple #7
0
    def wrapper(worker, job):
        try:
            k = job.task
            logs.begin(saveLog=api._logsDB.saveLog, saveStat=api._statsDB.addStat, nodeName=api.node_name)
            logs.async_request(k)
            v = functions[k]
            data = pickle.loads(job.data)
            logs.info("%s: %s: %s" % (k, v, data))
            v(k, data)
        except Exception as e:
            logs.error(str(e))
        finally:
            try:
                logs.save()
            except Exception:
                print "Unable to save logs"
                import traceback

                traceback.print_exc()
                logs.warning(traceback.format_exc())
        return ""
Exemple #8
0
 def wrapper(task_id, key, data, **kwargs):
     try:
         logs.begin(saveLog=api._logsDB.saveLog,
                    saveStat=api._statsDB.addStat,
                    nodeName=api.node_name)
         logs.async_request(key)
         logs.info("Request %s: %s: %s: %s" % (task_id, key, data, kwargs))
         handler(task_id, key, data, **kwargs)
         logs.info("Finished with request %s" % (task_id,))
     except Exception as e:
         logs.error("Failed request %s" % (task_id,))
         logs.report()
         _warningEmail('%s - %s failed (%s)' % (api.node_name, key, datetime.utcnow().isoformat()))
     finally:
         logs.info('Saving request log for request %s' % (task_id,))
         try:
             logs.save()
         except Exception:
             print 'Unable to save logs'
             import traceback
             traceback.print_exc()
             logs.warning(traceback.format_exc())
Exemple #9
0
def invoke(request, *args, **kwargs):
    """ 
        wrapper to invoke a stamped api function in an asynchronous context 
        which adds logging and exception handling.
    """
    
    taskId = kwargs.pop('taskId', None)

    try:
        stampedAPI = getStampedAPI()
        func = "%sAsync" % utils.getFuncName(1)
        
        if not request.is_eager:
            logs.begin(
                saveLog=stampedAPI._logsDB.saveLog,
                saveStat=stampedAPI._statsDB.addStat,
                nodeName=stampedAPI.node_name,
            )
            
            logs.async_request(func, *args, **kwargs)
        
        logs.info("%s %s %s (is_eager=%s, hostname=%s, task_id=%s)" % 
                  (func, args, kwargs, request.is_eager, request.hostname, request.id))

        getattr(stampedAPI, func)(*args, **kwargs)

    except Exception as e:
        logs.error(str(e))
        raise
    finally:
        try:
            if taskId is not None:
                stampedAPI._asyncTasksDB.removeTask(taskId)
            if not request.is_eager:
                logs.save()
        except:
            pass
Exemple #10
0
        def wrapper(request, *args, **kwargs):
            try:
                origin = None
                
                try:
                    origin = request.META['HTTP_ORIGIN']
                    valid_origin = origin
                    assert valid_origin in VALID_ORIGINS
                except Exception:
                    valid_origin = None
                
                def _add_cors_headers(response):
                    response['Access-Control-Allow-Origin']  = valid_origin
                    response['Access-Control-Allow-Methods'] = 'GET, POST, OPTIONS'
                    response['Access-Control-Max-Age']       = 1000
                    response['Access-Control-Allow-Headers'] = '*'
                    return response
                
                # allow API to gracefully handle cross-domain requests from trusted origins
                if request.method == 'OPTIONS' and valid_origin is not None:
                    return _add_cors_headers(HttpResponse())
                
                logs.begin(saveLog=stampedAPI._logsDB.saveLog,
                           saveStat=stampedAPI._statsDB.addStat,
                           requestData=request,
                           nodeName=stampedAPI.node_name)
                logs.info("%s %s" % (request.method, request.path))

                if valid_origin is None:
                    if origin is not None:
                        logs.warning("Invalid origin: %s" % origin)
                    else:
                        logs.debug("Origin not included")
                
                params = {}

                params['authUserId'], params['authClientId'] = checkOAuthWithRequest(request, requires_auth)
                params['client_id'] = checkClient(request, required=requires_client)
                
                if parse_request:
                    parse_kwargs = parse_request_kwargs or {}

                    if upload is not None:
                        if http_schema is None:
                            raise Exception("ERROR: handleHTTPRequest requires http_schema if upload is provided")
                        
                        params['http_schema']   = parseFileUpload(http_schema(), request, upload, **parse_kwargs)
                    elif http_schema is not None:
                        params['http_schema']   = parseRequest(http_schema(), request, **parse_kwargs)
                    else:
                        params['http_schema']   = parseRequest(None, request, **parse_kwargs)
                    
                    if conversion is not None:
                        params['schema']        = conversion(params['http_schema'])
                    elif http_schema is not None:
                        params['data']          = params['http_schema'].dataExport()

                if 'PATH_INFO' in request.META:
                    params['uri'] = request.META['PATH_INFO'].lower()
                
                kwargs.update(params)
                ret = fn(request, *args, **kwargs)
                logs.info("End request: Success")
                
                if valid_origin and isinstance(ret, HttpResponse):
                    _add_cors_headers(ret)
                
                return ret

            except Exception as e:
                return handleStampedExceptions(e, exceptions)
            finally:
                try:
                    logs.save()
                except Exception:
                    print 'Unable to save logs'
                    import traceback
                    traceback.print_exc()
                    logs.warning(traceback.format_exc())