Python connect_to_redis Examples

Example #1

File: __main__.py Project: onitu/onitu

def load_drivers(*args, **kwargs):
    logger.info("Loading entries...")

    redis = connect_to_redis()

    try:
        with open(entries_file) as f:
            entries = simplejson.load(f)
    except simplejson.JSONDecodeError as e:
        logger.error("Error parsing '{}' : {}", entries_file, e)
        loop.stop()
    except Exception as e:
        logger.error(
            "Can't process entries file '{}' : {}", entries_file, e
        )
        loop.stop()

    redis.delete('entries')
    redis.sadd('entries', *entries.keys())

    for name, conf in entries.items():
        logger.debug("Loading entry {}", name)

        if ':' in name:
            logger.error("Illegal character ':' in entry {}", name)
            continue

        script = 'onitu.drivers.{}'.format(conf['driver'])

        if 'options' in conf:
            redis.hmset('drivers:{}:options'.format(name), conf['options'])

        watcher = arbiter.add_watcher(
            name,
            sys.executable,
            args=['-m', script, name, log_uri],
            copy_env=True,
        )

        loop.add_callback(start_watcher, watcher)

    logger.debug("Entries loaded")

Example #2

def load_drivers(*args, **kwargs):
    logger.info("Loading entries...")

    redis = connect_to_redis()

    try:
        with open(entries_file) as f:
            entries = simplejson.load(f)
    except simplejson.JSONDecodeError as e:
        logger.error("Error parsing '{}' : {}", entries_file, e)
        loop.stop()
    except Exception as e:
        logger.error("Can't process entries file '{}' : {}", entries_file, e)
        loop.stop()

    redis.delete('entries')
    redis.sadd('entries', *entries.keys())

    for name, conf in entries.items():
        logger.debug("Loading entry {}", name)

        if ':' in name:
            logger.error("Illegal character ':' in entry {}", name)
            continue

        script = 'onitu.drivers.{}'.format(conf['driver'])

        if 'options' in conf:
            redis.hmset('drivers:{}:options'.format(name), conf['options'])

        watcher = arbiter.add_watcher(
            name,
            sys.executable,
            args=['-m', script, name, log_uri],
            copy_env=True,
        )

        loop.add_callback(start_watcher, watcher)

    logger.debug("Entries loaded")

Example #3

File: app.py Project: datastaxdevs/learningpath-docker

from flask import Flask
from flask import render_template
from flask import request
from flask import make_response
from utils import connect_to_redis
import os
import socket
import random
import json

option_a = os.getenv('OPTION_A', "Cats")
option_b = os.getenv('OPTION_B', "Dogs")
redis_host = os.getenv('REDIS_HOST', "redis")
hostname = socket.gethostname()

redis = connect_to_redis(redis_host)
app = Flask(__name__)


@app.route("/", methods=['POST', 'GET'])
def hello():
    voter_id = request.cookies.get('voter_id')
    if not voter_id:
        voter_id = hex(random.getrandbits(64))[2:-1]

    vote = None

    if request.method == 'POST':
        vote = request.form['vote']
        data = json.dumps({'voter_id': voter_id, 'vote': vote})
        redis.rpush('votes', data)

Example #4

File: app.py Project: mgoelzer/swarm-demo-voting-app

from flask import render_template
from flask import request
from flask import make_response
from utils import connect_to_redis
import os
import socket
import random
import json
import time

option_a = os.getenv('OPTION_A', "Cats")
option_b = os.getenv('OPTION_B', "Dogs")
hostname = socket.gethostname()

db_server = os.environ['QUEUE_HOSTNAME']
redis = connect_to_redis(db_server)
app = Flask(__name__)

@app.route("/env", methods=['GET'])
def dump_env():
    s = ''
    for key in os.environ.keys():
        s = "%s%30s=%s\n" % (s, key,os.environ[key])
    resp = make_response(render_template(
	    'env.html',
	    s=s
    ))
    return resp

@app.route("/", methods=['POST','GET'])
def index():

Example #5

File: app.py Project: herzogf/example-voting-app

from flask import render_template
from flask import request
from flask import make_response
from utils import connect_to_redis
import os
import socket
import random
import json

option_a = os.getenv('OPTION_A', "Cats")
option_b = os.getenv('OPTION_B', "Dogs")
hostname = socket.gethostname()

redis_hostname = os.getenv('REDIS_HOST', "voteapps_redis_1")

redis = connect_to_redis(redis_hostname)
app = Flask(__name__)


@app.route("/", methods=['POST','GET'])
def hello():
    voter_id = request.cookies.get('voter_id')
    if not voter_id:
        voter_id = hex(random.getrandbits(64))[2:-1]

    vote = None

    if request.method == 'POST':
        vote = request.form['vote']
        data = json.dumps({'voter_id': voter_id, 'vote': vote})
        redis.rpush('votes', data)

Example #6

File: app.py Project: azazel75/example-voting-app

from flask import Flask
from flask import render_template
from flask import request
from flask import make_response
from utils import connect_to_redis
import os
import socket
import random
import json

option_a = os.getenv("OPTION_A", "Cats")
option_b = os.getenv("OPTION_B", "Dogs")
hostname = socket.gethostname()

redis = connect_to_redis("voteapps_redis_1")
app = Flask(__name__)


@app.route("/", methods=["POST", "GET"])
def hello():
    voter_id = request.cookies.get("voter_id")
    if not voter_id:
        voter_id = hex(random.getrandbits(64))[2:-1]

    vote = None

    if request.method == "POST":
        vote = request.form["vote"]
        data = json.dumps({"voter_id": voter_id, "vote": vote})
        redis.rpush("votes", data)

Example #7

File: app.py Project: flmcloud/DCOSVotingApp

from flask import Flask
from flask import render_template
from flask import request
from flask import make_response
from utils import connect_to_redis
import os
import socket
import random
import json

option_a = os.getenv('OPTION_A', "Sun")
option_b = os.getenv('OPTION_B', "Rain")

hostname = socket.gethostname()

redis = connect_to_redis("redis.all.examplevotingapp.marathon.mesos")
app = Flask(__name__)


@app.route("/", methods=['POST','GET'])
def hello():
    voter_id = request.cookies.get('voter_id')
    if not voter_id:
        voter_id = hex(random.getrandbits(64))[2:-1]

    vote = None

    if request.method == 'POST':
        vote = request.form['vote']
        data = json.dumps({'voter_id': voter_id, 'vote': vote})
        redis.rpush('votes', data)

Example #8

File: app.py Project: surajssd/docker-birthday-3

from flask import request
from flask import make_response
from utils import connect_to_redis
import os
import socket
import random
import json

option_a = os.getenv('OPTION_A', "Python")
option_b = os.getenv('OPTION_B', "JavaScript")

hostname = socket.gethostname()

import os

redis = connect_to_redis(os.getenv("REDIS_SERVICE_HOST"))
app = Flask(__name__)


@app.route("/", methods=['POST', 'GET'])
def hello():
    voter_id = request.cookies.get('voter_id')
    if not voter_id:
        voter_id = hex(random.getrandbits(64))[2:-1]

    vote = None

    if request.method == 'POST':
        vote = request.form['vote']
        data = json.dumps({'voter_id': voter_id, 'vote': vote})
        redis.rpush('votes', data)

Example #9

File: app.py Project: code-monkeys/docker-voting-app

from flask import Flask
from flask import render_template
from flask import request
from flask import make_response
from utils import connect_to_redis
import os
import socket
import random
import json

option_a = os.getenv('OPTION_A', "Cats")
option_b = os.getenv('OPTION_B', "Dogs")
hostname = socket.gethostname()

redis = connect_to_redis("redis-voting.marathon.cell-1.ofi.mesos")
app = Flask(__name__)


@app.route("/", methods=['POST', 'GET'])
def hello():
    voter_id = request.cookies.get('voter_id')
    if not voter_id:
        voter_id = hex(random.getrandbits(64))[2:-1]

    vote = None

    if request.method == 'POST':
        vote = request.form['vote']
        data = json.dumps({'voter_id': voter_id, 'vote': vote})
        redis.rpush('votes', data)

Example #10

File: app.py Project: jawsug-container/example-voting-app

from flask import Flask
from flask import render_template
from flask import request
from flask import make_response
from utils import connect_to_redis
import os
import socket
import random
import json

option_a = os.getenv('OPTION_A', "Cats")
option_b = os.getenv('OPTION_B', "Dogs")
hostname = socket.gethostname()

redis = connect_to_redis(os.getenv('REDIS_HOST', "redis"))
app = Flask(__name__)


@app.route("/", methods=['POST','GET'])
def hello():
    voter_id = request.cookies.get('voter_id')
    if not voter_id:
        voter_id = hex(random.getrandbits(64))[2:-1]

    vote = None

    if request.method == 'POST':
        vote = request.form['vote']
        data = json.dumps({'voter_id': voter_id, 'vote': vote})
        redis.rpush('votes', data)

Example #11

File: app.py Project: Clabfabs/example-voting-app

@app.route("/", methods=['POST','GET'])
def hello():
	while True:
		try:	
			voter_id = request.cookies.get('voter_id')
			if not voter_id:
				voter_id = hex(random.getrandbits(64))[2:-1]

			vote = None

			if request.method == 'POST':
                requests.post(metrics_host + '/click', data={click: 1})
                vote = request.form['vote']
				data = json.dumps({'voter_id': voter_id, 'vote': vote})
				redis.rpush('votes', data)

			resp = make_response(render_template(
				'index.html',
				option_a=option_a,
				option_b=option_b,
				hostname=hostname,
				vote=vote,
			))
			resp.set_cookie('voter_id', voter_id)
			return resp
		except:
			redis = connect_to_redis(os.environ.get('REDIS_HOST'))

if __name__ == "__main__":
	app.run(host='0.0.0.0', port=80, debug=True)

Example #12

File: stu.py Project: zerolinke/swarm-demo-voting-app

from flask import request
from flask import make_response
from flask import render_template
from utils import connect_to_redis

import os
import socket
import random

option_a = os.getenv('OPTION_A', "Cats")
option_b = os.getenv('OPTION_B', "Dogs")
redishost = os.getenv('redishost', "0.0.0.0")
redisport = os.getenv('redisport', 6379)
hostname = socket.gethostname()

redis = connect_to_redis(redishost, redisport)
app = Flask(__name__)


@app.route('/', methods=['POST', 'GET'])
def hello():
    voter_id = request.cookies.get('voter_id')
    if not voter_id:
        voter_id = hex(random.getrandbits(64))[2:-1]
        print str(voter_id)

    vote = None

    if request.method == 'POST':
        vote = request.form['vote']
        data = json.dumps({'voter_id': voter_id, 'vote': vote})

Example #13

from flask import request
from flask import make_response
from flask import render_template
from utils import connect_to_redis

import os
import socket
import random

option_a = os.getenv('OPTION_A', "Cats")
option_b = os.getenv('OPTION_B', "Dogs")
redishost = os.getenv('redishost', "0.0.0.0")
redisport = os.getenv('redisport', 6379)
hostname = socket.gethostname()

redis = connect_to_redis(redishost, redisport)
app = Flask(__name__)


@app.route('/', methods=['POST', 'GET'])
def hello():
    voter_id = request.cookies.get('voter_id')
    if not voter_id:
        voter_id = hex(random.getrandbits(64))[2:-1]
        print str(voter_id)

    vote = None

    if request.method == 'POST':
        vote = request.form['vote']
        data = json.dumps({'voter_id': voter_id, 'vote': vote})

Example #14

File: app.py Project: code-monkeys/docker-voting-app

from flask import Flask
from flask import render_template
from flask import request
from flask import make_response
from utils import connect_to_redis
import os
import socket
import random
import json

option_a = os.getenv('OPTION_A', "Cats")
option_b = os.getenv('OPTION_B', "Dogs")
hostname = socket.gethostname()

redis = connect_to_redis("redis-voting.marathon.cell-1.ofi.mesos")
app = Flask(__name__)


@app.route("/", methods=['POST','GET'])
def hello():
    voter_id = request.cookies.get('voter_id')
    if not voter_id:
        voter_id = hex(random.getrandbits(64))[2:-1]

    vote = None

    if request.method == 'POST':
        vote = request.form['vote']
        data = json.dumps({'voter_id': voter_id, 'vote': vote})
        redis.rpush('votes', data)

Example #15

from flask import Flask
from flask import render_template
from flask import request
from flask import make_response
from utils import connect_to_redis
import os
import socket
import random
import json

option_a = os.getenv('OPTION_A', "One")
option_b = os.getenv('OPTION_B', "Two")

hostname = socket.gethostname()

redis = connect_to_redis("redis")
app = Flask(__name__)


@app.route("/", methods=['POST', 'GET'])
def hello():
    voter_id = request.cookies.get('voter_id')
    if not voter_id:
        voter_id = hex(random.getrandbits(64))[2:-1]

    vote = None

    if request.method == 'POST':
        vote = request.form['vote']
        data = json.dumps({'voter_id': voter_id, 'vote': vote})
        redis.rpush('votes', data)

Example #16

File: app.py Project: satyaki1008/votingapp1

from flask import Flask
from flask import render_template
from flask import request
from flask import make_response
from utils import connect_to_redis
import os
import socket
import random
import json

option_a = os.getenv('OPTION_A', "Cats")
option_b = os.getenv('OPTION_B', "Dogs")
hostname = socket.gethostname()

redis = connect_to_redis("voteapps_redis_1")
app = Flask(__name__)


@app.route("/", methods=['POST', 'GET'])
def hello():
    voter_id = request.cookies.get('voter_id')
    if not voter_id:
        voter_id = hex(random.getrandbits(64))[2:-1]

    vote = None

    if request.method == 'POST':
        vote = request.form['vote']
        data = json.dumps({'voter_id': voter_id, 'vote': vote})
        redis.rpush('votes', data)

Example #17

File: app.py Project: Eficode/devops2016_docker_demo

from flask import Flask
from flask import render_template
from flask import request
from flask import make_response
from utils import connect_to_redis
import os
import socket
import random
import json

option_a = os.getenv('OPTION_A', "Devops")
option_b = os.getenv('OPTION_B', "Sweating")

hostname = socket.gethostname()

redis = connect_to_redis("redis")
app = Flask(__name__)


@app.route("/", methods=['POST','GET'])
def hello():
    voter_id = request.cookies.get('voter_id')
    if not voter_id:
        voter_id = hex(random.getrandbits(64))[2:-1]

    vote = None

    if request.method == 'POST':
        vote = request.form['vote']
        data = json.dumps({'voter_id': voter_id, 'vote': vote})
        redis.rpush('votes', data)

Example #18

File: app.py Project: atsaurav1995/test1

from flask import render_template
from flask import request
from flask import make_response
from utils import connect_to_redis
import os
import socket
import random
import json
import time

option_a = os.getenv('OPTION_A', "Cats")
option_b = os.getenv('OPTION_B', "Dogs")
hostname = socket.gethostname()

db_server = "redis%s" % os.environ['WEB_VOTE_NUMBER']
redis = connect_to_redis(db_server)
app = Flask(__name__)


@app.route("/env", methods=['GET'])
def dump_env():
    s = ''
    for key in os.environ.keys():
        s = "%s%30s=%s\n" % (s, key, os.environ[key])
    resp = make_response(render_template('env.html', s=s))
    return resp


@app.route("/", methods=['POST', 'GET'])
def index():
    voter_id = request.cookies.get('voter_id')