예제 #1
0
 def _sendOneshot(self, oneshot):
     body = (' '.join('%s %s %s .' % (s.n3(), p.n3(), o.n3())
                      for s,p,o in oneshot)).encode('utf8')
     fetch(method='POST',
           url='http://bang6:9071/oneShot',
           headers={'Content-Type': ['text/n3']}, postdata=body,
           timeout=5)
예제 #2
0
파일: auth.py 프로젝트: VoiSmart/cyclone
    def twitter_request(self, path, callback, access_token=None,
                           post_args=None, **args):
        """Fetches the given API path, e.g., "/statuses/user_timeline/btaylor"

        The path should not include the format (we automatically append
        ".json" and parse the JSON output).

        If the request is a POST, post_args should be provided. Query
        string arguments should be given as keyword arguments.

        All the Twitter methods are documented at
        http://apiwiki.twitter.com/Twitter-API-Documentation.

        Many methods require an OAuth access token which you can obtain
        through authorize_redirect() and get_authenticated_user(). The
        user returned through that process includes an 'access_token'
        attribute that can be used to make authenticated requests via
        this method. Example usage:

        class MainHandler(tornado.web.RequestHandler,
                          tornado.auth.TwitterMixin):
            @tornado.web.authenticated
            @tornado.web.asynchronous
            def get(self):
                self.twitter_request(
                    "/statuses/update",
                    post_args={"status": "Testing Tornado Web Server"},
                    access_token=user["access_token"],
                    callback=self.async_callback(self._on_post))

            def _on_post(self, new_entry):
                if not new_entry:
                    # Call failed; perhaps missing permission?
                    self.authorize_redirect()
                    return
                self.finish("Posted a message!")

        """
        # Add the OAuth resource request signature if we have credentials
        url = "http://twitter.com" + path + ".json"
        if access_token:
            all_args = {}
            all_args.update(args)
            all_args.update(post_args or {})
            self._oauth_consumer_token()
            method = "POST" if post_args is not None else "GET"
            oauth = self._oauth_request_parameters(
                url, access_token, all_args, method=method)
            args.update(oauth)
        if args:
            url += "?" + urllib.urlencode(args)
        if post_args is not None:
            d = httpclient.fetch(url, method="POST",
                                 postdata=urllib.urlencode(post_args))
            d.addCallback(self.async_callback(self._on_twitter_request,
                          callback))
        else:
            d = httpclient.fetch(url)
            d.addCallback(self.async_callback(self._on_twitter_request,
                          callback))
예제 #3
0
 def _sendOneshot(self, oneshot):
     body = (' '.join('%s %s %s .' % (s.n3(), p.n3(), o.n3())
                      for s,p,o in oneshot)).encode('utf8')
     fetch(method='POST',
           url='http://bang6:9071/oneShot',
           headers={'Content-Type': ['text/n3']}, postdata=body,
           timeout=5)
예제 #4
0
    def _oneShotPostActions(self, deviceGraph, inferred):
        """
        Inferred graph may contain some one-shot statements. We'll send
        statement objects to anyone on web sockets, and also generate
        POST requests as described in the graph.

        one-shot statement ?s ?p ?o
        with this in the graph:
          ?osp a :OneShotPost
          ?osp :subject ?s
          ?osp :predicate ?p
        this will cause a post to ?o 
        """
        # nothing in this actually makes them one-shot yet. they'll
        # just fire as often as we get in here, which is not desirable
        log.info("_oneShotPostActions")
        def err(e):
            log.warn("post %s failed", postTarget)
        for osp in deviceGraph.subjects(RDF.type, ROOM['OneShotPost']):
            s = deviceGraph.value(osp, ROOM['subject'])
            p = deviceGraph.value(osp, ROOM['predicate'])
            if s is None or p is None:
                continue
            for postTarget in inferred.objects(s, p):
                log.info("post target %r", postTarget)
                # this packet ought to have 'oneShot' in it somewhere
                self.sendToLiveClients({"s":s, "p":p, "o":postTarget})

                log.info("    POST %s", postTarget)
                fetch(postTarget, method="POST", timeout=2).addErrback(err)
        self._postMpdCommands(inferred)
예제 #5
0
파일: auth.py 프로젝트: redbaron/cyclone
    def get_authenticated_user(self, callback):
        """Gets the OAuth authorized user and access token on callback.

        This method should be called from the handler for your registered
        OAuth Callback URL to complete the registration process. We call
        callback with the authenticated user, which in addition to standard
        attributes like 'name' includes the 'access_key' attribute, which
        contains the OAuth access you can use to make authorized requests
        to this service on behalf of the user.
        """
        request_key = self.get_argument("oauth_token")
        request_cookie = self.get_cookie("_oauth_request_token")
        if not request_cookie:
            log.err("Missing OAuth request token cookie")
            callback(None)
            return

        cookie_key, cookie_secret = request_cookie.split("|")
        if cookie_key != request_key:
            log.err("Request token does not match cookie")
            callback(None)
            return
        token = dict(key=cookie_key, secret=cookie_secret)
        httpclient.fetch(self._oauth_access_token_url(token))
        d.addCallback(self.async_callback(self._on_access_token, callback))
예제 #6
0
 def _sendOneshot(self, oneshot):
     body = (' '.join('%s %s %s .' % (s.n3(), p.n3(), o.n3())
                      for s,p,o in oneshot)).encode('utf8')
     bang6 = 'fcb8:4119:fb46:96f8:8b07:1260:0f50:fcfa'
     fetch(method='POST',
           url='http://[%s]:9071/oneShot' % bang6,
           headers={'Content-Type': ['text/n3']}, postdata=body,
           timeout=5)
예제 #7
0
파일: auth.py 프로젝트: jsandovalc/cyclone
    def authenticate_redirect(self):
        """Just like authorize_redirect(), but auto-redirects if authorized.

        This is generally the right interface to use if you are using
        Twitter for single-sign on.
        """
        httpclient.fetch(self._oauth_request_token_url()).addCallback(
            self.async_callback(
            self._on_request_token, self._OAUTH_AUTHENTICATE_URL, None))
예제 #8
0
    def authenticate_redirect(self):
        """Just like authorize_redirect(), but auto-redirects if authorized.

        This is generally the right interface to use if you are using
        Twitter for single-sign on.
        """
        httpclient.fetch(self._oauth_request_token_url()).addCallback(
            self.async_callback(self._on_request_token,
                                self._OAUTH_AUTHENTICATE_URL, None))
예제 #9
0
    def twitter_request(self, path, callback, access_token=None,
                           post_args=None, **args):
        """Fetches the given API path, e.g., "/statuses/user_timeline/btaylor"

        The path should not include the format (we automatically append
        ".json" and parse the JSON output).

        If the request is a POST, post_args should be provided. Query
        string arguments should be given as keyword arguments.

        All the Twitter methods are documented at
        http://apiwiki.twitter.com/Twitter-API-Documentation.

        Many methods require an OAuth access token which you can obtain
        through authorize_redirect() and get_authenticated_user(). The
        user returned through that process includes an 'access_token'
        attribute that can be used to make authenticated requests via
        this method. Example usage:

        class MainHandler(tornado.web.RequestHandler,
                          tornado.auth.TwitterMixin):
            @tornado.web.authenticated
            @tornado.web.asynchronous
            def get(self):
                self.twitter_request(
                    "/statuses/update",
                    post_args={"status": "Testing Tornado Web Server"},
                    access_token=user["access_token"],
                    callback=self.async_callback(self._on_post))

            def _on_post(self, new_entry):
                if not new_entry:
                    # Call failed; perhaps missing permission?
                    self.authorize_redirect()
                    return
                self.finish("Posted a message!")

        """
        # Add the OAuth resource request signature if we have credentials
        url = "http://twitter.com" + path + ".json"
        if access_token:
            all_args = {}
            all_args.update(args)
            all_args.update(post_args or {})
            consumer_token = self._oauth_consumer_token()
            method = "POST" if post_args is not None else "GET"
            oauth = self._oauth_request_parameters(
                url, access_token, all_args, method=method)
            args.update(oauth)
        if args: url += "?" + urllib.urlencode(args)
        if post_args is not None:
            d = httpclient.fetch(url, method="POST", postdata=urllib.urlencode(post_args))
            d.addCallback(self.async_callback(self._on_twitter_request, callback))
        else:
            d = httpclient.fetch(url)
            d.addCallback(self.async_callback(self._on_twitter_request, callback))
예제 #10
0
파일: auth.py 프로젝트: VoiSmart/cyclone
    def friendfeed_request(self, path, callback, access_token=None,
                           post_args=None, **args):
        """Fetches the given relative API path, e.g., "/bret/friends"

        If the request is a POST, post_args should be provided. Query
        string arguments should be given as keyword arguments.

        All the FriendFeed methods are documented at
        http://friendfeed.com/api/documentation.

        Many methods require an OAuth access token which you can obtain
        through authorize_redirect() and get_authenticated_user(). The
        user returned through that process includes an 'access_token'
        attribute that can be used to make authenticated requests via
        this method. Example usage:

        class MainHandler(tornado.web.RequestHandler,
                          tornado.auth.FriendFeedMixin):
            @tornado.web.authenticated
            @tornado.web.asynchronous
            def get(self):
                self.friendfeed_request(
                    "/entry",
                    post_args={"body": "Testing Tornado Web Server"},
                    access_token=self.current_user["access_token"],
                    callback=self.async_callback(self._on_post))

            def _on_post(self, new_entry):
                if not new_entry:
                    # Call failed; perhaps missing permission?
                    self.authorize_redirect()
                    return
                self.finish("Posted a message!")

        """
        # Add the OAuth resource request signature if we have credentials
        url = "http://friendfeed-api.com/v2" + path
        if access_token:
            all_args = {}
            all_args.update(args)
            all_args.update(post_args or {})
            self._oauth_consumer_token()
            method = "POST" if post_args is not None else "GET"
            oauth = self._oauth_request_parameters(
                url, access_token, all_args, method=method)
            args.update(oauth)
        if args:
            url += "?" + urllib.urlencode(args)
        if post_args is not None:
            d = httpclient.fetch(url, method="POST",
                                 postdata=urllib.urlencode(post_args))
            d.addCallback(self.async_callback(self._on_friendfeed_request,
                          callback))
        else:
            httpclient.fetch(url).addCallback(self.async_callback(
                self._on_friendfeed_request, callback))
예제 #11
0
파일: actions.py 프로젝트: drewp/homeauto
 def _put(self, url, payload, agent=None):
     assert isinstance(payload, bytes)
     def err(e):
         log.warn("    put %s failed (%r)", url, e)
     log.info("    PUT %s payload=%s agent=%s", url, payload, agent)
     headers = {}
     if agent is not None:
         headers['x-foaf-agent'] = [str(agent)]
     fetch(url, method="PUT", postdata=payload, timeout=2,
           headers=headers).addErrback(err)
예제 #12
0
    def facebook_request(self,
                         path,
                         callback,
                         access_token=None,
                         post_args=None,
                         **args):
        """Fetches the given relative API path, e.g., "/btaylor/picture"

        If the request is a POST, post_args should be provided. Query
        string arguments should be given as keyword arguments.

        An introduction to the Facebook Graph API can be found at
        http://developers.facebook.com/docs/api

        Many methods require an OAuth access token which you can obtain
        through authorize_redirect() and get_authenticated_user(). The
        user returned through that process includes an 'access_token'
        attribute that can be used to make authenticated requests via
        this method. Example usage::

            class MainHandler(cyclone.web.RequestHandler,
                              cyclone.auth.FacebookGraphMixin):
                @cyclone.web.authenticated
                @cyclone.web.asynchronous
                def get(self):
                    self.facebook_request(
                        "/me/feed",
                        post_args={"message": "Posting from my cyclone app!"},
                        access_token=self.current_user["access_token"],
                        callback=self.async_callback(self._on_post))

                def _on_post(self, new_entry):
                    if not new_entry:
                        # Call failed; perhaps missing permission?
                        self.authorize_redirect()
                        return
                    self.finish("Posted a message!")

        """
        url = "https://graph.facebook.com" + path
        all_args = {}
        if access_token:
            all_args["access_token"] = access_token
            all_args.update(args)

        if all_args:
            url += "?" + urllib_parse.urlencode(all_args)
        callback = self.async_callback(self._on_facebook_request, callback)
        if post_args is not None:
            httpclient.fetch(url,
                             method="POST",
                             postdata=urllib_parse.urlencode(
                                 post_args)).addCallback(callback)
        else:
            httpclient.fetch(url).addCallback(callback)
예제 #13
0
    def friendfeed_request(self, path, callback, access_token=None,
                           post_args=None, **args):
        """Fetches the given relative API path, e.g., "/bret/friends"

        If the request is a POST, post_args should be provided. Query
        string arguments should be given as keyword arguments.

        All the FriendFeed methods are documented at
        http://friendfeed.com/api/documentation.

        Many methods require an OAuth access token which you can obtain
        through authorize_redirect() and get_authenticated_user(). The
        user returned through that process includes an 'access_token'
        attribute that can be used to make authenticated requests via
        this method. Example usage::

            class MainHandler(cyclone.web.RequestHandler,
                              cyclone.auth.FriendFeedMixin):
                @cyclone.web.authenticated
                @cyclone.web.asynchronous
                def get(self):
                    self.friendfeed_request(
                        "/entry",
                        post_args={"body": "Testing cyclone Web Server"},
                        access_token=self.current_user["access_token"],
                        callback=self.async_callback(self._on_post))

                def _on_post(self, new_entry):
                    if not new_entry:
                        # Call failed; perhaps missing permission?
                        self.authorize_redirect()
                        return
                    self.finish("Posted a message!")
        """
        # Add the OAuth resource request signature if we have credentials
        url = "http://friendfeed-api.com/v2" + path
        if access_token:
            all_args = {}
            all_args.update(args)
            all_args.update(post_args or {})
            method = "POST" if post_args is not None else "GET"
            oauth = self._oauth_request_parameters(
                url, access_token, all_args, method=method)
            args.update(oauth)
        if args:
            url += "?" + urllib_parse.urlencode(args)
        if post_args is not None:
            d = httpclient.fetch(url, method="POST",
                                 postdata=urllib_parse.urlencode(post_args))
            d.addCallback(self.async_callback(self._on_friendfeed_request,
                          callback))
        else:
            httpclient.fetch(url).addCallback(self.async_callback(
                self._on_friendfeed_request, callback))
예제 #14
0
    def get_authenticated_user(self,
                               redirect_uri,
                               client_id,
                               client_secret,
                               code,
                               callback,
                               extra_fields=None):
        """Handles the login for the Facebook user, returning a user object.

        Example usage::

            class FacebookGraphLoginHandler(LoginHandler,
                                            cyclone.auth.FacebookGraphMixin):
              @cyclone.web.asynchronous
              def get(self):
                  if self.get_argument("code", False):
                      self.get_authenticated_user(
                        redirect_uri='/auth/facebookgraph/',
                        client_id=self.settings["facebook_api_key"],
                        client_secret=self.settings["facebook_secret"],
                        code=self.get_argument("code"),
                        callback=self.async_callback(
                          self._on_login))
                      return
                  self.authorize_redirect(
                        redirect_uri='/auth/facebookgraph/',
                        client_id=self.settings["facebook_api_key"],
                        extra_params={"scope": "read_stream,offline_access"})

              def _on_login(self, user):
                logging.error(user)
                self.finish()

        """
        args = {
            "redirect_uri": redirect_uri,
            "code": code,
            "client_id": client_id,
            "client_secret": client_secret,
        }

        fields = set([
            'id', 'name', 'first_name', 'last_name', 'locale', 'picture',
            'link'
        ])
        if extra_fields:
            fields.update(extra_fields)

        httpclient.fetch(self._oauth_request_token_url(**args))\
        .addCallback(self.async_callback(
                            self._on_access_token, redirect_uri, client_id,
                            client_secret, callback, fields))
예제 #15
0
 def delete_object(self, bucket_name, object_name):
     bucket = self.riak_client.bucket(bucket_name)
     obj = yield bucket.get_binary(object_name)
     if obj.exists():
         _object = json.loads(obj.get_data())
         if 'ObjectPath' in object_name: 
             httpclient.fetch('http://127.0.0.1:8098/%s' % _object['ObjectPath'], method="DELETE")
             log.msg('Deleted object %s from bucket %s on %s' % (object_name, bucket_name, _object['ObjectPath']))
         else:
             log.msg('Deleted object %s from bucket %s' % (object_name, bucket_name))
         obj.delete()
         defer.returnValue(True)
     defer.returnValue(False)
예제 #16
0
    def get_authenticated_user(self, callback):
        """Fetches the authenticated user data upon redirect.

        This method should be called by the handler that receives the
        redirect from the authenticate_redirect() or authorize_redirect()
        methods.
        """
        # Verify the OpenID response via direct request to the OP
        args = dict((k, v[-1]) for k, v in self.request.arguments.iteritems())
        args["openid.mode"] = u"check_authentication"
        url = self._OPENID_ENDPOINT + "?" + urllib.urlencode(args)
        callback = self.async_callback(self._on_authentication_verified, callback)
        httpclient.fetch(url).addBoth(callback)
예제 #17
0
파일: auth.py 프로젝트: powo/cyclone
    def get_authenticated_user(self, callback):
        """Fetches the authenticated user data upon redirect.

        This method should be called by the handler that receives the
        redirect from the authenticate_redirect() or authorize_redirect()
        methods.
        """
        # Verify the OpenID response via direct request to the OP
        args = dict((k, v[-1]) for k, v in self.request.arguments.items())
        args["openid.mode"] = u"check_authentication"
        url = self._OPENID_ENDPOINT
        callback = self.async_callback(self._on_authentication_verified, callback)
        httpclient.fetch(url, method="POST", postdata=urllib.urlencode(args)).addBoth(callback)
예제 #18
0
파일: auth.py 프로젝트: jsandovalc/cyclone
    def facebook_request(self, path, callback, access_token=None,
                           post_args=None, **args):
        """Fetches the given relative API path, e.g., "/btaylor/picture"

        If the request is a POST, post_args should be provided. Query
        string arguments should be given as keyword arguments.

        An introduction to the Facebook Graph API can be found at
        http://developers.facebook.com/docs/api

        Many methods require an OAuth access token which you can obtain
        through authorize_redirect() and get_authenticated_user(). The
        user returned through that process includes an 'access_token'
        attribute that can be used to make authenticated requests via
        this method. Example usage::

            class MainHandler(cyclone.web.RequestHandler,
                              cyclone.auth.FacebookGraphMixin):
                @cyclone.web.authenticated
                @cyclone.web.asynchronous
                def get(self):
                    self.facebook_request(
                        "/me/feed",
                        post_args={"message": "Posting from my cyclone app!"},
                        access_token=self.current_user["access_token"],
                        callback=self.async_callback(self._on_post))

                def _on_post(self, new_entry):
                    if not new_entry:
                        # Call failed; perhaps missing permission?
                        self.authorize_redirect()
                        return
                    self.finish("Posted a message!")

        """
        url = "https://graph.facebook.com" + path
        all_args = {}
        if access_token:
            all_args["access_token"] = access_token
            all_args.update(args)

        if all_args:
            url += "?" + urllib.urlencode(all_args)
        callback = self.async_callback(self._on_facebook_request, callback)
        if post_args is not None:
            httpclient.fetch(url, method="POST",
                    postdata=urllib.urlencode(post_args)).addCallback(callback)
        else:
            httpclient.fetch(url).addCallback(callback)
예제 #19
0
    def get(self):
        try:
            cpOrderId = self.get_argument("cpOrderId")
            orderStatus = self.get_argument("orderStatus")
            payFee = self.get_argument("payFee")
            payTime = self.get_argument("payTime")
            signature = self.get_argument("signature")  
            cpUserInfo = self.get_argument("cpUserInfo")             
        except Exception:
            raise web.HTTPError(400, "Argument error")
        params = self.request.arguments.copy()
        params.pop('signature')
        for x, y in params.items():
            params[x] = y[0]
        params = yield self.format_params(params, False)
        m = hashlib.md5()   
        m.update(params) 
        _sign = m.hexdigest()  
        if signature != _sign:
            url = "%s/xmpay/notify/" % cpUserInfo
            params = dict(cpOrderId=cpOrderId, orderStatus=orderStatus, payFee=payFee, payTime=payTime)
            yield httpclient.fetch(httputil.url_concat(url, params))

            ret = dict(error_code=200)
        else:
            ret = dict(error_code=1525, errMsg=E.errmsg(E.ERR_SIGN))
        reb = zlib.compress(escape.json_encode(ret))
        self.write(ret)
예제 #20
0
    def event_toughcloud_mail_account_expire(self, userinfo):
        """ toughcloud mail api notify event """
        if not userinfo:
            return

        api_secret = self.get_param_value("toughcloud_license")
        service_mail = self.get_param_value("toughcloud_service_mail")
        if not service_mail:
            return
        api_token = yield tools.get_sys_token()
        params = dict(token=api_token.strip(),
                      mailto=userinfo.email,
                      tplname=self.MAIL_TPLNAME,
                      customer=utils.safestr(userinfo.realname),
                      username=userinfo.account_number,
                      product=utils.safestr(userinfo.product_name),
                      expire=userinfo.expire_date,
                      service_call=self.get_param_value(
                          "toughcloud_service_call", ''),
                      service_mail=service_mail,
                      nonce=str(int(time.time())))
        params['sign'] = apiutils.make_sign(api_secret.strip(),
                                            params.values())
        try:
            resp = yield httpclient.fetch(self.MAIL_APIURL,
                                          postdata=urlencode(params))
            logger.info(resp.body)
        except Exception as err:
            logger.exception(err)
예제 #21
0
 def post(self):
     dom = parseString(self.request.body)  
     root = dom.firstChild 
     childs = root.childNodes
     for child in childs: 
         if child.nodeType == child.TEXT_NODE:
             pass
         else:
             if child.nodeName == 'contentId':
                 contentId = child.childNodes[0].data
             elif child.nodeName == 'consumeCode':
                 consumeCode = child.childNodes[0].data
             elif child.nodeName == 'cpid':
                 cpid = child.childNodes[0].data
             elif child.nodeName == 'hRet':
                 hRet = child.childNodes[0].data                   
             elif child.nodeName == 'cpparam':
                 print child.childNodes[0].data.encode("utf-8")
                 orderId, zoneid = child.childNodes[0].data.split('%2C')
             else:pass
     res = yield self.sql.runQuery("SELECT domain FROM core_zone WHERE zoneid=%s", (zoneid, ))
     if res:
         domain, = res[0] 
     url = "%s/cmpay/notify/" % domain
     params = dict(orderId=orderId, contentId=contentId, consumeCode=consumeCode, cpid=cpid, hRet=hRet)
     yield httpclient.fetch(httputil.url_concat(url, params))
     self.write('''<?xml version="1.0" encoding="UTF-8"?> <request><hRet>0</hRet><message>Successful</message> </request>''')
예제 #22
0
    def getPresentMacAddrs_multirouter(self):
        rows = []
        
        for router in self.routers:
            log.debug("GET %s", router)
            try:
                resp = yield fetch(router.url, headers=router.headers,
                                   timeout=2)
            except socket.error:
                log.warn("get on %s failed" % router)
                continue
            data = resp.body
            if 'Wireless -- Authenticated Stations' in data:
                # zyxel 'Station Info' page
                rows.extend(self._parseZyxel(data, router.name))
            else:
                # tomato page
                rows.extend(self._parseTomato(data, router.name))

        for r in rows:
            try:
                r['name'] = self.knownMacAddr[r['mac']]
            except KeyError:
                pass
                
        returnValue(rows)
예제 #23
0
def loadCiscoData():
    config = json.load(open("/my/proj/homeauto/service/tomatoWifi/priv-uva.json"))
    headers = {'Authorization': ['Basic %s' % config['userPass'].encode('base64').strip()]}
    print headers
    resp = yield fetch('http://10.2.0.2/', headers=headers)
    print resp.body
    returnValue([])
예제 #24
0
파일: pay.py 프로젝트: pengfangzhou/AcgZone
    def post(self):
        logging.info("/shafa/notify/ start")
        params = self.request.arguments.copy()
        logging.info(params)
        try:
            data = self.get_argument("data")
        except Exception:
            logging.error("/shafa/notify/ 获得的传入参数有误")
            self.write("获得的传入参数有误")
            return

        data_json = json.loads(data)
        price = data_json['price']
        quantity = data_json['quantity']
        custom_data = data_json['custom_data']
        time = data_json['time']
        custom_data = data_json['custom_data']
        logging.info("/shafa/notify/ 1 custom_data:"+custom_data)
        custom_data_json = json.loads(custom_data)
        ptorder = custom_data_json['ptorder']
        app_order_id,hurl = ptorder.split('_')
        url = "%s/shafa/notify/" % hurl
        print "shafa notify url:",url
        params = dict(app_order_id=app_order_id, price=price, quantity=quantity, time=time)
        respose = yield httpclient.fetch(httputil.url_concat(url, params))
        self.write("SUCCESS")
        logging.info("/shafa/notify/ end")
예제 #25
0
 def process(self, *args, **kwargs):
     next_interval = self.get_notify_interval()
     user_total = 0
     online_total = 0
     with make_db(self.db) as db:
         try:
             user_total = db.query(models.TrAccount).count()
             online_total = db.query(models.TrOnline).count()
         except Exception as err:
             pass
     try:
         api_url = "https://www.toughcloud.net/api/v1/ping"
         api_token = yield tools.get_sys_token()
         params = dict(
             token=api_token,
             app="toughradius",
             ver=__version__,
             release=self.config.system.get('release', "standard"),
             unum=user_total,
             onum=online_total,
             dist=' '.join(pf.linux_distribution()),
         )
         param_str = urlencode(params)
         resp = yield httpclient.fetch(api_url + "?" + param_str,
                                       followRedirect=True)
         logger.info("toughcloud ping resp code: %s" % resp.code)
     except Exception as err:
         logger.error(err)
     defer.returnValue(next_interval)
예제 #26
0
 def process(self, *args, **kwargs):
     next_interval = self.get_notify_interval()
     user_total = 0
     online_total = 0
     with make_db(self.db) as db:
         try:
             user_total = db.query(models.TrAccount).count()
             online_total = db.query(models.TrOnline).count()
         except Exception as err:
             pass
     try:
         api_url = "https://www.toughcloud.net/api/v1/ping"
         api_token = yield tools.get_sys_token()
         params = dict(
             token=api_token,
             app="toughradius",
             ver=__version__,
             release=self.config.system.get('release',"standard"),
             unum=user_total,
             onum=online_total,
             dist=' '.join(pf.linux_distribution()),
         )
         param_str = urlencode(params)
         resp = yield httpclient.fetch(api_url+"?"+param_str,followRedirect=True)
         logger.info("toughcloud ping resp code: %s"%resp.code)
     except Exception as err:
         logger.error(err)
     defer.returnValue(next_interval)
예제 #27
0
    def post(self):
        headers = {"Content-type": ["application/x-www-form-urlencoded"]}
        username = self.get_argument("username")

        params = [username]

        sign = mksign(self.settings.config.defaults.secret, params)

        post_data={"userName":username,"sign":sign}
        body = urllib.urlencode(post_data)

        radius_list = self.db.query(models.TraRadius).all()

        packets = []

        for radius in radius_list:
            try:
                resp = yield httpclient.fetch("http://%s:1815/api/queryPacketRecord" %radius.ip_addr, postdata=body, headers=headers)
                resp_msg = json.loads(resp.body)
                packets.extend(resp_msg.get('data') or [])
                log.msg(u'%s recieve a response ' %radius.ip_addr)
            except Exception, e:
                import traceback
                log.msg(u'%s cannot recieve a response, check this radius client please' %radius.ip_addr)
                traceback.print_exc()
예제 #28
0
def index(req):
    url = req.get_argument("q", None)
    if url:
        if os.path.exists(req.settings.cache.getpath(url)):
            print 'true???'
            req.redirect("/mustashify?q=" + url)
            defer.returnValue(None)
    else:
        req.render("index.html", err={})
        defer.returnValue(None)

    if not url.startswith("http"):
        url = "http://" + url

    try:
        tmp = urlparse.urlparse(url)
        assert tmp.scheme
        assert tmp.netloc
    except:
        req.render("index.html", err={"url": True})
        defer.returnValue(None)

    try:
        response = yield fetch(url, followRedirect=1, maxRedirects=3)
        assert response.code == 200, "Bad response code %s" % response.code
    except Exception, e:
        #log.err()
        req.render("index.html", err={"fetch": True})
        defer.returnValue(None)
예제 #29
0
    def ping(self):
        conn = self.db()
        try:
            nonce = str(time.time())
            action = "ping"
            headers = {"Content-Type": ["application/json"]}
            for oss in conn.query(models.TraOssServer):
                try:
                    sign = self.mksign(oss.secret, params=[action, nonce])
                    reqdata = json.dumps(dict(action=action, nonce=nonce, sign=sign))
                    resp = yield httpclient.fetch(oss.admin_url, postdata=reqdata, headers=headers)
                    if resp.code != 200:
                        self.syslog.error("ping oss <%s> error,http status = %s" % (oss.admin_url, resp.code))
                        continue

                    jsonresp = json.loads(resp.body)
                    if jsonresp['code'] == 0:
                        oss.last_check = utils.get_currtime()

                except Exception as err:
                    defer.returnValue("ping oss <%s> error, %s" % (oss.admin_url, str(err)))

            conn.commit()
            defer.returnValue("ping oss success")
        except Exception as err:
            defer.returnValue("ping oss error, %s" % str(err))
        finally:
            conn.close()
예제 #30
0
파일: pay.py 프로젝트: pengfangzhou/AcgZone
 def post(self):
     logging.info("/cmpay/notify/ start")
     dom = parseString(self.request.body)  
     root = dom.firstChild 
     childs = root.childNodes
     for child in childs: 
         if child.nodeType == child.TEXT_NODE:
             pass
         else:
             if child.nodeName == 'contentId':
                 contentId = child.childNodes[0].data
             elif child.nodeName == 'consumeCode':
                 consumeCode = child.childNodes[0].data
             elif child.nodeName == 'cpid':
                 cpid = child.childNodes[0].data
             elif child.nodeName == 'hRet':
                 hRet = child.childNodes[0].data                   
             elif child.nodeName == 'cpparam':
                 print child.childNodes[0].data.encode("utf-8")
                 orderId, zoneid = child.childNodes[0].data.split('%2C')
             else:pass
     res = yield self.sql.runQuery("SELECT domain FROM core_zone WHERE zoneid=%s", (zoneid, ))
     if res:
         domain, = res[0] 
     url = "%s/cmpay/notify/" % domain
     params = dict(orderId=orderId, contentId=contentId, consumeCode=consumeCode, cpid=cpid, hRet=hRet)
     yield httpclient.fetch(httputil.url_concat(url, params))
     self.write('''<?xml version="1.0" encoding="UTF-8"?> <request><hRet>0</hRet><message>Successful</message> </request>''')
     logging.info("/cmpay/notify/ end")
예제 #31
0
파일: musta.py 프로젝트: lxfontes/mustash
def mustashify(req):
    url = req.get_argument("q")
    try:
        response = yield fetch(url, followRedirect=1, maxRedirects=3)
    except Exception, e:
        #log.err()
        raise web.HTTPError(404)
예제 #32
0
파일: pay.py 프로젝트: pengfangzhou/AcgZone
    def get(self):
        logging.info("/xmpay/notify/ start")
        try:
            cpOrderId = self.get_argument("cpOrderId")
            orderStatus = self.get_argument("orderStatus")
            payFee = self.get_argument("payFee")
            payTime = self.get_argument("payTime")
            signature = self.get_argument("signature")  
            cpUserInfo = self.get_argument("cpUserInfo")             
        except Exception:
            raise web.HTTPError(400, "Argument error")

        params = self.request.arguments.copy()
        params.pop('signature')
        for x, y in params.items():
            params[x] = y[0]
        params = yield self.format_params(params, False)
        m = hashlib.md5()   
        m.update(params) 
        _sign = m.hexdigest()  
        if signature != _sign:
            url = "%s/xmpay/notify/" % cpUserInfo
            params = dict(cpOrderId=cpOrderId, orderStatus=orderStatus, payFee=payFee, payTime=payTime)
            yield httpclient.fetch(httputil.url_concat(url, params))

            ret = dict(error_code=200)
        else:
            ret = dict(error_code=1525, errMsg=E.errmsg(E.ERR_SIGN))
        reb = zlib.compress(escape.json_encode(ret))
        self.write(ret)
        logging.info("XmNotifyHandler /xmpay/notify/ end.")
예제 #33
0
def setColor(lightName, rgb):
    """takes 10-bit r,g,b

    returns even if the server is down
    """
    log.debug("setColor(%r,%r)", lightName, rgb)
  
    serv = lightResource[lightName]

    h = hexFromRgb(rgb)
    log.debug("put %r to %r", h, serv)
    t1 = time.time()
    d = fetch(url=serv, method='PUT', postdata=h,
              headers={'content-type': ['text/plain']})

    def err(e):
        log.warn("http client error on %s: %s" % (serv, e))
        raise e
    d.addErrback(err)


    def done(ret):
        log.debug('put took %.1fms', 1000 * (time.time() - t1))
    d.addCallback(done)
    return d
예제 #34
0
    def add_portal(self):
        sign = self.mksign(params=[
            self.server.portal_name,
            self.server.portal_addr,
            self.server.admin_listen,
            self.server.api_secret,
            self.server.port,
            self.server.listen,
            self.server.ac1[0]
        ])
        reqdata = json.dumps(dict(
            name=self.server.portal_name,
            ip_addr=self.server.portal_addr,
            admin_port=self.server.admin_listen,
            secret=self.server.api_secret,
            http_port=self.server.port,
            listen_port=self.server.listen,
            ac_server=self.server.ac1[0],
            sign=sign
        ))
        if self.server.debug:
            self.syslog.debug("register portal request:  %s" % reqdata)
        d = httpclient.fetch("%s/portal/add" % self.server.apiurl,
                             postdata=reqdata, headers={"Content-Type": ["application/json"]})

        d.addCallback(self.on_add_portal)
예제 #35
0
파일: base.py 프로젝트: 727340503/portal
    def get_template_attrs(self,ssid):
        cache_key = '{0}{1}'.format('get_template_attrs', ssid)
        _resp = portal_cache.get(cache_key)
        if _resp:
            if self.settings.debug:
                self.syslog.debug("query template request hit cache; key=%s" % cache_key)
            defer.returnValue(_resp)
            return

        sign = self.mksign(params=[ssid])
        reqdata = json.dumps(dict(ssid=ssid, sign=sign))
        apiurl = "%s/tpl/query" % self.settings.apiurl
        if self.settings.debug:
            self.syslog.debug("query template request (%s):  %s" % (apiurl,reqdata))
        resp = yield httpclient.fetch(apiurl,postdata=reqdata, headers={"Content-Type": ["application/json"]})

        jsonresp = json.loads(resp.body)
        if jsonresp['code'] == 1:
            self.syslog.error("query template attrs error, %s" % jsonresp['msg'])
            defer.returnValue({'tpl_name':'default'})
            return

        if jsonresp['code'] == 0:
            self.syslog.info("query template attrs success")
            portal_cache.set(cache_key, jsonresp['attrs'], expire=60)
            defer.returnValue(jsonresp['attrs'])
예제 #36
0
파일: pay.py 프로젝트: pengfangzhou/AcgZone
    def get(self):
        logging.info("/lgpay/notify/ start")
        try:
            serial_no = self.get_argument("serial_no")
            transaction_id = self.get_argument("transaction_id")
            result_code = self.get_argument("result_code")
            fee = self.get_argument("fee")           
        except Exception:
            raise web.HTTPError(400, "Argument error")

        r,zoneid = serial_no.split('_')
        logging.info("/lgpay/notify/ zoneid:",zoneid)
        res = yield self.sql.runQuery("SELECT domain FROM core_zone WHERE zoneid=%s", (zoneid, ))
        if res:
            domain, = res[0] 
        if int(result_code) == 120:
            url = "%s/lgpay/notify/" % domain
            logging.info("/lgpay/notify/ url:",url)

            params = dict(serial_no=serial_no, transaction_id=transaction_id, fee=fee)
            yield httpclient.fetch(httputil.url_concat(url, params))
            ret = dict(serial_no=serial_no)
            reb = zlib.compress(escape.json_encode(ret))
            self.write(ret)
            logging.info("/lgpay/lgpay/ end")
예제 #37
0
파일: dyncommands.py 프로젝트: drewp/magma
    def more(self):

        trs = [T.tr['']]

        response = yield fetch("http://bang:8007/commands",
                               headers={"X-Foaf-Agent": [str(self.user)]})
        if not response:
            raise ValueError(
                '-H "X-Foaf-Agent: %s" http://bang:8007/commands failed' %
                str(self.user))
        cmds = jsonlib.loads(response.body)

        belowZero = []

        for (cmd, score) in cmds:
            cmd = URIRef(cmd)
            if score < 0:
                belowZero.append((cmd, score))
                continue

            if len(trs[-1].children) >= 1 + columns:
                trs.append(T.tr[''])
            trs[-1].children.append(T.td["\n", self._buttonForm(cmd, score)])

        trs.append(T.tr[T.td(colspan=columns)])
        for (cmd, score) in belowZero:
            trs[-1].children[-1][self._buttonForm(cmd, score)]
        returnValue(T.table[trs])
예제 #38
0
    def event_toughcloud_sms_account_open(self, userinfo):
        """ toughCloud sms api open notify event """
        if not userinfo:
            return

        if not userinfo.get('phone'):
            logger.error('user phone is None exit')
            return

        api_secret = self.get_param_value("toughcloud_license")
        api_token = yield tools.get_sys_token()
        params = dict(
            token=api_token.strip(),
            action='sms',
            tplname=self.SMS_TPLNAME,
            phone=userinfo.get('phone'),
            customer=utils.safestr(userinfo.get('realname')),
            username=userinfo.get('account_number'),
            product=utils.safestr(userinfo.get('product_name')),
            password=userinfo.get('password'),
            expire=userinfo.get('expire_date'),
            nonce=str(int(time.time()))
        )
        params['sign'] = apiutils.make_sign(api_secret.strip(), params.values())
        try:
            resp = yield httpclient.fetch(self.SMS_APIURL, postdata=urlencode(params))
            logger.info(resp.body)
            logger.info('open account send short message success')
        except Exception as err:
            logger.exception(err)
예제 #39
0
    def event_toughcloud_mail_account_open(self, userinfo):
        """ toughCloud mail api open notify without password event """
        if not userinfo:
            return

        if not userinfo.get('email'):
            logger.error('user email is None exit')
            return

        try:
            api_secret = self.get_param_value("toughcloud_license")
            service_mail = self.get_param_value("toughcloud_service_mail")
            if not service_mail:
                return
            api_token = yield tools.get_sys_token()
            params = dict(
                token=api_token.strip(),
                action='email',
                mailto=userinfo.get('email'),
                tplname=self.MAIL_TPLNAME,
                customer=utils.safestr(userinfo.get('realname')),
                username=userinfo.get('account_number'),
                product=utils.safestr(userinfo.get('product_name')),
                expire=userinfo.get('expire_date'),
                service_call=self.get_param_value("toughcloud_service_call", ''),
                service_mail=service_mail,
                nonce=str(int(time.time()))
            )
            params['sign'] = apiutils.make_sign(api_secret.strip(), params.values())
            resp = yield httpclient.fetch(self.MAIL_APIURL, postdata=urlencode(params))
            logger.info(resp.body)
            logger.info('open account send email without password success')
        except Exception as err:
            logger.exception(err)
예제 #40
0
파일: musictime.py 프로젝트: drewp/light9
    def pollMusicTime(self):
        def cb(response):

            if response.code != 200:
                raise ValueError("%s %s", response.code, response.body)

            position = json.loads(response.body)

            # this is meant to be the time when the server gave me its
            # report, and I don't know if that's closer to the
            # beginning of my request or the end of it (or some
            # fraction of the way through)
            self.positionFetchTime = time.time()

            self.position = position
            self.onChange(position)

            reactor.callLater(self.period, self.pollMusicTime)
            
        def eb(err):
            log.warn("talking to ascoltami: %s", err.getErrorMessage())
            reactor.callLater(2, self.pollMusicTime)
            
        d = fetch(networking.musicPlayer.path("time"))
        d.addCallback(cb)
        d.addErrback(eb) # note this includes errors in cb()
예제 #41
0
    def get_authenticated_user(self, callback):
        """Gets the OAuth authorized user and access token on callback.

        This method should be called from the handler for your registered
        OAuth Callback URL to complete the registration process. We call
        callback with the authenticated user, which in addition to standard
        attributes like 'name' includes the 'access_key' attribute, which
        contains the OAuth access you can use to make authorized requests
        to this service on behalf of the user.
        """
        request_key = escape.utf8(self.get_argument("oauth_token"))
        oauth_verifier = self.get_argument("oauth_verifier", None)
        request_cookie = self.get_cookie("_oauth_request_token")
        if not request_cookie:
            log.msg("Missing OAuth request token cookie")
            callback(None)
            return
        self.clear_cookie("_oauth_request_token")
        cookie_key, cookie_secret = [
            base64.b64decode(escape.utf8(i)) for i in request_cookie.split("|")
        ]
        if cookie_key != request_key:
            log.msg("Request token does not match cookie")
            callback(None)
            return
        token = dict(key=cookie_key, secret=cookie_secret)
        if oauth_verifier:
            token["verifier"] = oauth_verifier
        d = httpclient.fetch(self._oauth_access_token_url(token))
        d.addCallback(self.async_callback(self._on_access_token, callback))
예제 #42
0
    def process(self, *args, **kwargs):
        next_interval = self.get_next_interval()
        user_total = 0
        online_total = 0
        with make_db(self.db) as db:
            try:
                user_total = db.query(models.TrAccount).count()
                online_total = db.query(models.TrOnline).count()
            except Exception as err:
                pass

        try:
            api_url = 'http://www.taurusxcloud.net/api/v1/ping'
            api_token = yield tools.get_sys_token()
            params = dict(token=api_token,
                          app='taurusxee',
                          ver=__version__,
                          release=os.environ.get('LICENSE_TYPE', 'taurusxee'),
                          unum=user_total,
                          onum=online_total,
                          dist=pf.linux_distribution())
            param_str = urlencode(params)
            resp = yield httpclient.fetch(api_url + '?' + param_str,
                                          followRedirect=True)
            logger.info('taurusxcloud ping resp code: %s' % resp.code)
        except Exception as err:
            logger.error(err)

        defer.returnValue(next_interval)
예제 #43
0
    def event_toughcloud_sms_account_open(self, userinfo):
        """ toughCloud sms api open notify event """
        if not userinfo:
            return

        if not userinfo.get('phone'):
            logger.error('user phone is None exit')
            return

        api_secret = self.get_param_value("toughcloud_license")
        api_token = yield tools.get_sys_token()
        params = dict(token=api_token.strip(),
                      action='sms',
                      tplname=self.SMS_TPLNAME,
                      phone=userinfo.get('phone'),
                      customer=utils.safestr(userinfo.get('realname')),
                      username=userinfo.get('account_number'),
                      product=utils.safestr(userinfo.get('product_name')),
                      password=userinfo.get('password'),
                      expire=userinfo.get('expire_date'),
                      nonce=str(int(time.time())))
        params['sign'] = apiutils.make_sign(api_secret.strip(),
                                            params.values())
        try:
            resp = yield httpclient.fetch(self.SMS_APIURL,
                                          postdata=urlencode(params))
            logger.info(resp.body)
            logger.info('open account send short message success')
        except Exception as err:
            logger.exception(err)
예제 #44
0
    def event_toughcloud_mail_account_expire(self, userinfo):
        """ toughcloud mail api notify event """
        if not userinfo:
            return

        api_secret = self.get_param_value("toughcloud_license")
        service_mail=self.get_param_value("toughcloud_service_mail")
        if not service_mail:
            return
        api_token = yield tools.get_sys_token()
        params = dict(
            token=api_token.strip(),
            mailto=userinfo.email,
            tplname=self.MAIL_TPLNAME,
            customer=utils.safestr(userinfo.realname),
            username=userinfo.account_number,
            product=utils.safestr(userinfo.product_name),
            expire=userinfo.expire_date,
            service_call=self.get_param_value("toughcloud_service_call",''),
            service_mail=service_mail,
            nonce = str(int(time.time()))
        )
        params['sign'] = apiutils.make_sign(api_secret.strip(), params.values())
        try:
            resp = yield httpclient.fetch(self.MAIL_APIURL, postdata=urlencode(params))
            logger.info(resp.body)
        except Exception as err:
            logger.exception(err)
예제 #45
0
파일: musta.py 프로젝트: fiorix/mustash
def index(req):
    url = req.get_argument("q", None)
    if url:
        if os.path.exists(req.settings.cache.getpath(url)):
            print 'true???'
            req.redirect("/mustashify?q="+url)
            defer.returnValue(None)
    else:
        req.render("index.html", err={})
        defer.returnValue(None)

    if not url.startswith("http"):
        url = "http://"+url

    try:
        tmp = urlparse.urlparse(url)
        assert tmp.scheme
        assert tmp.netloc
    except:
        req.render("index.html", err={"url":True})
        defer.returnValue(None)

    try:
        response = yield fetch(url, followRedirect=1, maxRedirects=3)
        assert response.code == 200, "Bad response code %s" % response.code
    except Exception, e:
        #log.err()
        req.render("index.html", err={"fetch":True})
        defer.returnValue(None)
예제 #46
0
파일: dyncommands.py 프로젝트: drewp/magma
    def more(self):

        trs = [T.tr['']]

        response = yield fetch("http://bang:8007/commands",
                               headers={"X-Foaf-Agent":[str(self.user)]})
        if not response:
            raise ValueError('-H "X-Foaf-Agent: %s" http://bang:8007/commands failed' % str(self.user))
        cmds = jsonlib.loads(response.body)

        belowZero = []

        for (cmd, score) in cmds:
            cmd = URIRef(cmd)
            if score < 0:
                belowZero.append((cmd, score))
                continue

            if len(trs[-1].children) >= 1 + columns:
                trs.append(T.tr[''])
            trs[-1].children.append(T.td["\n", self._buttonForm(cmd, score)])

        trs.append(T.tr[T.td(colspan=columns)])
        for (cmd, score) in belowZero:
            trs[-1].children[-1][self._buttonForm(cmd, score)]
        returnValue(T.table[trs])
예제 #47
0
    def event_toughcloud_mail_account_open(self, userinfo):
        """ toughCloud mail api open notify without password event """
        if not userinfo:
            return

        if not userinfo.get('email'):
            logger.error('user email is None exit')
            return

        try:
            api_secret = self.get_param_value("toughcloud_license")
            service_mail = self.get_param_value("toughcloud_service_mail")
            if not service_mail:
                return
            api_token = yield tools.get_sys_token()
            params = dict(token=api_token.strip(),
                          action='email',
                          mailto=userinfo.get('email'),
                          tplname=self.MAIL_TPLNAME,
                          customer=utils.safestr(userinfo.get('realname')),
                          username=userinfo.get('account_number'),
                          product=utils.safestr(userinfo.get('product_name')),
                          expire=userinfo.get('expire_date'),
                          service_call=self.get_param_value(
                              "toughcloud_service_call", ''),
                          service_mail=service_mail,
                          nonce=str(int(time.time())))
            params['sign'] = apiutils.make_sign(api_secret.strip(),
                                                params.values())
            resp = yield httpclient.fetch(self.MAIL_APIURL,
                                          postdata=urlencode(params))
            logger.info(resp.body)
            logger.info('open account send email without password success')
        except Exception as err:
            logger.exception(err)
예제 #48
0
    def poll(self):
        ret = None
        startTime = time.time()
        try:
            url = (f'http://{deviceIp}/cgi-bin/cgi_manager').encode('ascii')
            resp = yield fetch(
                url,
                method=b'POST',
                headers={b'Authorization': [b'Basic %s' % auth]},
                postdata=(f'''<LocalCommand>
                              <Name>get_usage_data</Name>
                              <MacId>0x{macId}</MacId>
                            </LocalCommand>
                            <LocalCommand>
                              <Name>get_price_blocks</Name>
                              <MacId>0x{macId}</MacId>
                            </LocalCommand>''').encode('ascii'),
                timeout=10)
            ret = json.loads(resp.body)
            log.debug(ret)
            if ret['demand_units'] != 'kW':
                raise ValueError
            if ret['summation_units'] != 'kWh':
                raise ValueError
            pts = [
                dict(measurement='housePowerW',
                     fields=dict(value=float(ret['demand']) * 1000),
                     tags=dict(house='berkeley'),
                     time=int(startTime))]
            sd = float(ret['summation_delivered'])
            if sd > 0: # Sometimes nan
                pts.append(dict(measurement='housePowerSumDeliveredKwh',
                                fields=dict(value=float()),
                                tags=dict(house='berkeley'),
                                time=int(startTime)))
            if 'price' in ret:
                pts.append(dict(
                    measurement='price',
                    fields=dict(price=float(ret['price']),
                                price_units=float(ret['price_units'])),
                    tags=dict(house='berkeley'),
                    time=int(startTime),
                ))

            self.influx.write_points(pts, time_precision='s')

            self.graph.patchObject(context=ROOM['powerEagle'],
                                         subject=ROOM['housePower'],
                                         predicate=ROOM['instantDemandWatts'],
                                         newObject=Literal(float(ret['demand']) * 1000))
        except Exception as e:
            traceback.print_exc()
            log.error("failed: %r", e)
            log.error(repr(ret))
            os.abort()

        now = time.time()
        goal = startTime + periodSec - .2
        reactor.callLater(max(1, goal - now), self.poll)
예제 #49
0
파일: client.py 프로젝트: drewp/photo
def changed(uri):
    """call this to rescan an image"""
    # errors?
    url = 'http://%s:%s/update' % networking.imageSet()
    log.info('post %r for index update', url)
    return fetch(url,
                 method='POST',
                 postdata=urllib.urlencode([('uri', str(uri))]))
예제 #50
0
 def getSimilarDocs(self, doc_id, limit=10, skip=0):
     search_url = 'http://%s:%s/%s/%s/%s/_mlt?mlt_fields=content' % (
         self.config.host, self.config.port, self.config.index,
         self.config.document_type, str(doc_id))
     response = yield httpclient.fetch(search_url, method='POST')
     jsondata = json.loads(response.body)
     jsondata = jsondata["hits"]["hits"]
     jsondata = [x["_source"] for x in jsondata][:3]
     defer.returnValue(jsondata)
예제 #51
0
    def authorize_redirect(self, callback_uri=None):
        """Redirects the user to obtain OAuth authorization for this service.

        Twitter and FriendFeed both require that you register a Callback
        URL with your application. You should call this method to log the
        user in, and then call get_authenticated_user() in the handler
        you registered as your Callback URL to complete the authorization
        process.

        This method sets a cookie called _oauth_request_token which is
        subsequently used (and cleared) in get_authenticated_user for
        security purposes.
        """
        if callback_uri and getattr(self, "_OAUTH_NO_CALLBACKS", False):
            raise Exception("This service does not support oauth_callback")
        callback = self.async_callback(self._on_request_token,
                                       self._OAUTH_AUTHORIZE_URL, callback_uri)
        httpclient.fetch(self._oauth_request_token_url()).addCallback(callback)
예제 #52
0
    def request(self, path, method="GET", postdata=None, headers={}):
        url = "http://localhost:%s%s" % (self.port, path)
        if isinstance(postdata, dict):
            postdata = json.dumps(postdata)

        response = yield httpclient.fetch(url, method=method,
                                          postdata=postdata,
                                          headers=headers)
        defer.returnValue(response)
예제 #53
0
 def post_request(self, requestURL, requestArgs):
     headers = {'Content-Type': ['application/json']}
     url = base_url + requestURL
     data = json.dumps(requestArgs)
     response = yield httpclient.fetch(url,
                                       method='POST',
                                       headers=headers,
                                       postdata=data)
     response = json.loads(response.body)
     defer.returnValue(response)
예제 #54
0
 def getDocument(self, doc_id):
     qry = {"query": {"bool": {"must": [{"term": {"doc.did": doc_id}}]}}}
     search_url = 'http://%s:%s/%s/%s/_search' % (
         self.config.host, self.config.port, self.config.index,
         self.config.document_type)
     response = yield httpclient.fetch(search_url,
                                       method='POST',
                                       postdata=json.dumps(qry))
     jsondata = json.loads(response.body)
     jsondata = jsondata["hits"]["hits"][0]["_source"]
     defer.returnValue(jsondata)
예제 #55
0
 def send_sms(self, phone, tplid, args = [], kwargs = {}):
     smsapiurl = '{0}/taurusxee/sendsms'.format(self.url)
     kwargs['apikey'] = self.apiuser
     kwargs['phone'] = phone
     kwargs['tplname'] = tplid
     kwargs['timestamp'] = long(time.time())
     kwargs['sign'] = apiutils.make_sign(self.apikey, kwargs.values())
     postdata = urlencode(kwargs)
     resp = yield httpclient.fetch(smsapiurl, postdata=postdata)
     ret = json.loads(resp.body)
     defer.returnValue(ret['code'] == 0)
예제 #56
0
파일: multiclient.py 프로젝트: drewp/pixel
    def _req(method, url, body, headers):
        d = fetch(url=url,
                  method=method,
                  postdata=body,
                  headers=dict((k, [v]) for k, v in headers.items()))

        @d.addErrback
        def err(e):
            log.warn("http client error on %s: %s" % (url, e))
            raise e

        return d
예제 #57
0
파일: dyncommands.py 프로젝트: drewp/magma
 def addData(source):
     try:
         trig = (yield fetch(source)).body
     except AttributeError:
         print vars()
         raise
     try:
         g.addN(parseTrig(trig))
     except Exception:
         import traceback
         print "fetching %s:" % source
         traceback.print_exc()
예제 #58
0
 def send_sms(self, phone, tplid, args = [], kwargs = {}):
     smspwd = md5(utils.safestr('%s%s' % (self.apiuser, self.apikey))).hexdigest()
     _params = dict(ac='send', uid=utils.safestr(apikey), pwd=smspwd, mobile=utils.safestr(phone), content=utils.safestr(json.dumps(kwargs, ensure_ascii=False)))
     sms_api_url = '%s?%s' % (self.url, urlencode(_params))
     resp = yield httpclient.fetch(sms_api_url, followRedirect=True)
     if '200' != str(resp.status_code):
         defer.returnValue(True)
     else:
         ret = json.loads(resp.body)
         if self.debug:
             logger.info(ret)
         defer.returnValue(ret['stat'] == 0)
예제 #59
0
 def process(self, *args, **kwargs):
     next_interval = self.get_notify_interval()
     try:
         api_url = "https://www.toughcloud.net/api/v1/ping"
         api_token = yield tools.get_sys_token()
         param_str = urlencode({'token': api_token})
         resp = yield httpclient.fetch(api_url + "?" + param_str,
                                       followRedirect=True)
         logger.info("toughcloud ping resp code: %s" % resp.code)
         if resp.code == 200:
             self.cache.set(toughcloud_ping_key, resp.body, expire=3600)
     except Exception as err:
         logger.error(err)
     defer.returnValue(next_interval)