- Build JavaScript assets. Add ``--w`` for live reloading::

- profile page.  Once there are some messages that get into your local database

- # encoding=utf8

- '''

- This file is for development purposes only.

- 

- The end goal is for the streaming server to be implemented on the FMN side

- '''

- import json

- import logging

- import sys

- import trollius

- import trollius_redis

- import urllib2

- from concurrent.futures import TimeoutError

- from trollius import From

- 

- reload(sys)

- sys.setdefaultencoding('utf8')

- 

- log = logging.getLogger(__name__)

- SERVER = None

- REDIS_HOST = '0.0.0.0'

- REDIS_PORT = 6379

- REDIS_DB = 0

- EVENTSOURCE_PORT = 9090

- '''

- you need to

- 

- pip install trollius trollius_redis

- 

- dnf install redis httpie

- systemctl start redis

- 

- 

- usage: http get 0.0.0.0:9090/

- 

- '''

- 

- 

- def get_recent_posts():

-     delta = "delta=86400"  # one day worth of data

-     rows_per_page = "rows_per_page=50"

-     url = "https://apps.fedoraproject.org/datagrepper/raw" + "?" + delta + "&" + rows_per_page

-     request = urllib2.Request(url)

-     contents = urllib2.urlopen(request).read()

-     json_response = json.loads(contents)

-     return json_response['raw_messages']

- 

- 

- @trollius.coroutine

- def handle_client(client_reader, client_writer):

-     origin = '*'

-     if origin.endswith('/'):

-         origin = origin[:-1]

- 

-     client_writer.write(("HTTP/1.0 200 OK\n"

-                          "Content-Type: text/event-stream\n"

-                          "Cache: nocache\n"

-                          "Connection: keep-alive\n"

-                          "Access-Control-Allow-Origin: %s\n\n" % origin

-                          ).encode())

- 

-     connection = yield trollius.From(trollius_redis.Connection.create(

-         host=REDIS_HOST, port=REDIS_PORT,

-         db=REDIS_DB))

- 

-     try:

-         posts = get_recent_posts()

- 

-         # send 50 latest posts

-         num_post_sent = 0

-         while num_post_sent < 50:

-             reply = posts[num_post_sent]

-             reply = json.dumps(reply)

-             log.info(reply)

-             log.info("Sending post %s %s", str(num_post_sent), reply)

-             client_writer.write(('data: %s\n\n' % reply).encode())

-             yield trollius.From(client_writer.drain())

-             num_post_sent += 1

-             yield From(trollius.sleep(2))

- 

-     except trollius.ConnectionResetError:

-         log.exception("ERROR: ConnectionResetError in handle_client")

-     except Exception:

-         log.exception("ERROR: Exception in handle_client")

-     finally:

-         # Wathever happens, close the connection.

-         connection.close()

-         client_writer.close()

- 

- 

- def main():

-     global SERVER

- 

-     try:

-         loop = trollius.get_event_loop()

-         coro = trollius.start_server(handle_client,

-                                      host=None,

-                                      port=EVENTSOURCE_PORT,

-                                      loop=loop)

-         SERVER = loop.run_until_complete(coro)

-         log.info('Serving server at {}'.format(SERVER.sockets[0].getsockname(

-         )))

-         loop.run_forever()

-     except KeyboardInterrupt:

-         pass

-     except trollius.ConnectionResetError as err:

-         log.exception("ERROR: ConnectionResetError in main")

-     except Exception as err:

-         log.exception("ERROR: Exception in main")

-     finally:

-         # Close the server

-         SERVER.close()

-         log.info("End Connection")

-         loop.run_until_complete(SERVER.wait_closed())

-         loop.close()

-         log.info("End")

- 

- 

- if __name__ == '__main__':

-     log = logging.getLogger("")

-     formatter = logging.Formatter(

-         "%(asctime)s %(levelname)s [%(module)s:%(lineno)d] %(message)s")

- 

-     # setup console logging

-     log.setLevel(logging.DEBUG)

-     ch = logging.StreamHandler()

-     ch.setLevel(logging.DEBUG)

- 

-     aslog = logging.getLogger("asyncio")

-     aslog.setLevel(logging.DEBUG)

- 

-     ch.setFormatter(formatter)

-     log.addHandler(ch)

-     main()

- 

- 

- PATHS = fmn.lib.load_rules(root='fmn.rules')

- 

- 

- @app.route('/api/fedmsg/markup', methods=['GET'])

- def markup_fedmsg():

-     '''

-     This is a temporary endpoint to create a human-readable form of a message.

-     For now it serves as a development tool

- 

-     This route will be removed once its functionality is integrated into FMN

-     '''

-     from hubs.widgets.feed import (

-         apply_markup, rehydrate_preference,

-         get_remote_preference

-     )

-     try:

-         data = flask.request.args['message']

-         plugin = flask.request.args['plugin']

-     except KeyError:

-         return flask.abort(400)

- 

-     widget = hubs.models.Widget.by_plugin(session, plugin)

- 

-     if not widget:

-         return flask.abort(400)

- 

-     context = widget.config.get('fmn_context')

- 

-     messages = []

-     message = json.loads(data)

- 

-     if 'topic' not in message:

-         return flask.abort(400)

- 

-     try:

-         nickname = flask.g.auth.nickname

-     except AttributeError:      # Not logged in

-         return flask.abort(403)

- 

-     preference = get_remote_preference(nickname, context)

- 

-     if preference:

-         try:

-             preference = rehydrate_preference(preference)

-         except ImportError:

-             pass

-     recipients = fmn.lib.recipients(

-         [preference], message, PATHS, fedmsg_config)

-     if recipients:

-         messages.append(message)

-     matches = fedmsg.meta.conglomerate(messages, lexers=True, **fedmsg_config)

- 

-     for match in matches:

-         match['markup'] = apply_markup(match)

-         for _, constituent in match['msg_ids'].items():

-             constituent['markup'] = apply_markup(constituent)

-             if constituent['long_form'] != constituent['subtitle']:

-                 if constituent.get('lexer'):

-                     constituent['long_form'] = pygments.highlight(

-                         constituent['long_form'],

-                         constituent['lexer'],

-                         pygments.formatters.HtmlFormatter(style='monokai'),

-                     )

-                 else:

-                     markup = u"<h5>{long_form}</h5>".format(**constituent)

-                     constituent['long_form'] = markup

- 

-         # And tack on a unique identifier for each top level entry.

-         match['dom_id'] = six.text_type(uuid.uuid4())

- 

-     return flask.jsonify(matches)

-             'fmn_context': 'irc',  # TODO -- make this 'hubs'

- import React from 'react';

- 

- export default class Constituent extends React.Component {

-     render() {

-         const match = this.props.match;

-         const hasConstituent = (match['msg_ids'].length === 1 && Object.keys(match['msg_ids'])[0]['long_form'] !== Object.keys(match['msg_ids'])[0]['subtitle']);

-         if ( hasConstituent ) {

-             const constituentKey = Object.keys(match['msg_ids'])[0];

-             const constituent = match['msg_ids'][constituentKey];

-             const differentIcon = constituent['icon'] != constituent['__icon__'];

-             const longLink = ( constituent['link'] && constituent['long_form'].indexOf(constituent['link']) === -1 );

- 

-             let constituentIcon;

-             if (differentIcon)

-                 constituentIcon = (

-                     <div className="media-left media-top">

-                         <a href={constituent['link']}>

-                             <img className="media-object" src={constituent['icon']} alt={constituent['subtitle']}/>

-                         </a>

-                     </div>

- 

-                 )

- 

-             let readMore;

-             if(longLink)

-                 readMore = (

-                     <div className="media-body">

-                         {constituent['long_form']}

-                         <a href={constituent['link']} target="_blank">

-                             Read more <span class="glyphicon glyphicon-new-window"></span>

-                         </a>

-                     </div>

-                 )

- 

-             return (

-                 <div id="content-{{match['dom_id']}}" className="media">

-                     <ExpandCollapse match={this.props.match} />

-                     {constituentIcon}

-                     {readMore}

-                 </div>

-             )

-         } else if (match['msg_ids'].length > 1) {

-             <div id="content-{{match['dom_id']}}" className="media">

-                 <ExpandCollapse match={this.props.match} />

-                 <MessageList msgs={this.match['msg_ids']} />

-             </div>

-         }

-         else {

-             return null

-         }

-     }

- }

- import React from 'react';

- 

- export default class ExpandCollapse extends React.Component {

-     render() {

-         return (

-             <div className="pull-right">

-                 <a id="expand-{this.props.match['dom_id']}" href="javascript:expand_feed_entries({this.props.match['dom_id']});" className="hidden">

-                     <span className="glyphicon glyphicon-chevron-down"></span>

-                     expand

-                 </a>

-                 <a id="collapse-{this.props.match['dom_id']}" href="javascript:collapse_feed_entries('{this.props.match['dom_id']}');">

-                     <span className="glyphicon glyphicon-chevron-up"></span>

-                     collapse

-                 </a>

-             </div>

-         )

-     }

- }

- import {render} from 'react-dom';

- 

- import Constituent from './Constituent.jsx';

- import ExpandCollapse from './ExpandCollapse.jsx';

- import Icon from './Icon.jsx';

- import Markup from './Markup.jsx';

- import {Message, MessageList} from './Messages.jsx';

- 

- 

- class Panel extends React.Component {

-     render() {

-         return (

-             <div className="panel panel-default">

-                 <div className="panel-body">

-                     <Icon match={this.props.match} />

-                     <Markup match={this.props.match} />

-                     <Constituent match={this.props.match} />

-                 </div>

-             </div>

-         );

-     }

- }

-     constructor (props) {

-         super(props);

-         this.state = {

-             matches: this.props.matches,

-             sse: true,

-         }

-         this.source = (!!window.EventSource) ? new EventSource('http://localhost:9090') : {};

-         this.source.addEventListener('error', () => {

-             this.state.sse = false;

-         }, false);

-         window.onbeforeunload = () => {

-             this.source.close();

-         }

-         this.source.addEventListener('message', resp => {

-             $.get('/api/fedmsg/markup', {

-                 message: resp.data,

-                 plugin: 'feed',

-             }).done(data => {

-                 if(!$.isEmptyObject(data)) {

-                     this.state.matches.push.apply(this.state.matches, data);

-                     this.setState({matches: this.state.matches});

-                 }

-             });

-         }, false);

-     }

-     render() {

-         const feedNodes = this.state.matches.map(match => {

-             return <Panel match={match}/>

-         });

-         return (

-             <div>

-                 {feedNodes}

-             </div>

-         )

-     }

- 

- export default class Icon extends React.Component {

-     render() {

-         return (

-             <div>

-                 <div className="media-left">

-                     <a href={this.props.match['link'] ? this.props.match['link'] : '#'} target="_blank">

-                         <img className="media-object square-32 img-circle" src={this.props.match['secondary_icon']} />

-                     </a>

-                 </div>

-             </div>

-         )

-     }

- }

-     createMarkup() {

-         return {__html: this.props.match['markup']};

-     }

-     render() {

-         return (

-             <div className="media-body">

-                 <h4 className="media-heading"

-                     dangerouslySetInnerHTML={this.createMarkup()}

-                 ></h4>

-                 {this.props.match['human_time']}

-             </div>

-         )

-     }

- import React from 'react';

- 

- class Message extends React.Component {

-     render() {

-         if(this.props.constituent['link']) {

-             return (

-                 <li>

-                     {this.props.constituent['markup']}

-                     <a href={this.props.constituent['link']} target="_blank">

-                         <span className="glyphicon glyphicon-new-window"></span>

-                     </a>

-                 </li>

-             )

-         } else {

-             return (<li>{ this.props.constituent['markup'] }</li>)

-         }

-     }

- }

- 

- class MessageList extends React.Component {

-     render() {

-         const messageNodes =  this.props.items.map(function(item) {

-             return <Message constituent={item}/>;

-         });

-         return (

-             <ul id="content-{this.props.match['dom_id']}" className="hidden list-unstyled">

-                 {messageNodes}

-             </ul>

-         )

-     }

- }

- 

- module.exports = {

-     Message: Message,

-     MessageList: MessageList

- }

- import React from 'react';

- import { render } from 'react-dom';

- 

- import Feed from './components/Feed.jsx'

- 

-     "babel-core": "~6.9.1",

-     "reactify": "~1.1.1",

-     "eslint-config-airbnb": "~9.0.1",

-     "eslint-plugin-react": "~5.2.1",

-     "eslint-plugin-jsx-a11y": "~1.5.3",

-     "eslint-plugin-import": "~1.8.1",

-     "eslint": "~2.12.0"

-     "test": "echo \"Error: no test specified\" && exit 1"

-   "author": "",

-   "license": "BSD"

- import json

- import os

- 

- import hubs.tests

- import hubs.models

- from hubs.app import app

- from hubs.tests import json_path

- 

- 

- class TestFeed(hubs.tests.APPTest):

- 

-     with open(json_path + 'message_involved.json', 'r') as fp:

-         message_involved = json.loads(fp.read())

- 

-     with open(json_path + 'message_not_involved.json', 'r') as fp:

-         message_not_involved = json.loads(fp.read())

- 

-     # TODO this test relies on a specific filter for the atelic user

-     # It would be better to fake preferences on FAS

-     user = hubs.tests.FakeAuthorization('atelic')

- 

-     plugin = 'feed'

- 

-     def test_returns_400_when_no_message(self):

-         payload = {'plugin': 'feed'}

-         response = self.app.get('/api/fedmsg/markup', query_string=payload)

-         self.assertEqual(response.status_code, 400)

- 

-     def test_returns_400_when_no_plugin(self):

-         payload = {'message': json.dumps(self.message_involved)}

-         response = self.app.get('/api/fedmsg/markup', query_string=payload)

-         self.assertEqual(response.status_code, 400)

- 

-     def test_returns_400_when_bad_plugin_name(self):

-         payload = {

-             'message': json.dumps(self.message_involved),

-             'plugin': 'notarealplugin'

-         }

-         response = self.app.get('/api/fedmsg/markup', query_string=payload)

-         self.assertEqual(response.status_code, 400)

- 

-     def test_returns_403_when_not_logged_in(self):

-         payload = {

-             'message': json.dumps(self.message_involved),

-             'plugin': 'feed'

-         }

- 

-         response = self.app.get('/api/fedmsg/markup', query_string=payload)

-         self.assertEqual(response.status_code, 403)

- 

-     def test_returns_match_if_involved(self):

-         payload = {

-             'message': json.dumps(self.message_involved),

-             'plugin': 'feed'

-         }

-         with self.app.session_transaction() as sess:

-             sess['nickname'] = 'atelic'

- 

-         with hubs.tests.auth_set(app, self.user):

-             response = self.app.get('/api/fedmsg/markup', query_string=payload)

- 

-             self.assertEqual(response.status_code, 200)

-             data = json.loads(response.data)

-             self.assertTrue(data)

-             self.assertTrue(isinstance(data[0], dict))

- 

-     def test_returns_no_match_if_not_involved(self):

-         payload = {

-             'message': json.dumps(self.message_not_involved),

-             'plugin': 'feed'

-         }

-         with self.app.session_transaction() as sess:

-             sess['nickname'] = 'atelic'

- 

-         with hubs.tests.auth_set(app, self.user):

-             response = self.app.get('/api/fedmsg/markup', query_string=payload)

- 

-             self.assertEqual(response.status_code, 200)

-             data = json.loads(response.data)

-             self.assertFalse(data)

-             expected_str = '<input id="fmn_context" class="form-control" type="text"'

- # No chrome around the feed.

- # from hubs.widgets.chrome import panel

- # chrome = panel()

- @argument(name="fmn_context",

-           default="irc",  # TODO - Make this 'hubs', or...

-           validator=validators.fmn_context,

-           help="A FMN context.")

- def data(session, widget, username, fmn_context):

-     preference = get_remote_preference(username, fmn_context)

-                 rows_per_page=bazillion,

-     return dict(matches=matches)

-     fmn_context = widget.config['fmn_context']

-      const FeedElement = React.createElement(Feed, {

-          matches: {{ matches }}

-      });

- 

-      reactRender(FeedElement, document.getElementById('feed'));

- 

- flask-oidc