def set_region(region_name):
try:
cbi = ConnectionBorg()
cbi.set_region(region_name)
except Exception, e:
print "Problem changing regions for dynamodb connection"
raise
def set_region(region_name):
try:
cbi = ConnectionBorg()
cbi.set_region(region_name)
except Exception, e:
print "Problem changing regions for dynamodb connection"
raise
def handle(self, *args, **options):
conn = ConnectionBorg()
conn.set_credentials(aws_access_key_id=settings.DYNAMODB_SESSIONS_AWS_ACCESS_KEY_ID,
aws_secret_access_key=settings.DYNAMODB_SESSIONS_AWS_SECRET_ACCESS_KEY,)
try:
conn.create_table(Contributor, 10, 10, wait_for_active=False)
self.stdout.write("Contributor table created")
except DynamoDBResponseError, er:
print(er)
def create_dynamoDB():
conn = ConnectionBorg()
conn.set_region( '%s' % settings.DATABASES["default"]["REGION"] )
obj_click = Click()
try:
conn.create_table(obj_click, read_units=settings.DATABASES["default"]["READ_UNITS"], write_units=settings.DATABASES["default"]["WRITE_UNITS"], wait_for_active=False)
except Exception, args:
print args
def test_borgness(self):
aws_access_key_id = "foo"
aws_secret_access_key = "bar"
borg1 = ConnectionBorg()
borg2 = ConnectionBorg()
borg1.set_credentials(aws_access_key_id, aws_secret_access_key)
self.assertEqual(borg1._aws_access_key_id, aws_access_key_id)
self.assertEqual(borg1._aws_secret_access_key, aws_secret_access_key)
self.assertEqual(borg2._aws_access_key_id, aws_access_key_id)
self.assertEqual(borg2._aws_secret_access_key, aws_secret_access_key)
def test_get_connection(self, m_boto):
CONNECTION = "JJG"
REGION = "La bas, tout est neuf et tout est sauvage."
KEY_ID = "foo"
KEY_VALUE = "bar"
m_boto.connect_dynamodb.return_value = "JJG"
borg1 = ConnectionBorg()
borg2 = ConnectionBorg()
borg1._region = REGION
borg1._aws_access_key_id = KEY_ID
borg1._aws_secret_access_key = KEY_VALUE
self.assertIsNone(borg1._connection)
self.assertEqual(CONNECTION, borg2._get_connection())
self.assertEqual(CONNECTION, borg1._get_connection())
self.assertEqual(CONNECTION, borg1._connection)
m_boto.connect_dynamodb.assert_called_once_with(
aws_access_key_id=KEY_ID,
aws_secret_access_key=KEY_VALUE,
region=REGION,
)
def test_set_credentials(self, m_boto):
# Make sure internal state is set and shared
m_get_table = m_boto.connect_dynamodb.return_value.get_table
aws_access_key_id = "foo"
aws_secret_access_key = "bar"
table_name = "foo"
borg1 = ConnectionBorg()
borg2 = ConnectionBorg()
borg1.set_credentials(aws_access_key_id, aws_secret_access_key)
self.assertIs(borg1._aws_access_key_id ,aws_access_key_id)
self.assertIs(borg2._aws_access_key_id ,aws_access_key_id)
self.assertIs(borg1._aws_secret_access_key ,aws_secret_access_key)
self.assertIs(borg2._aws_secret_access_key ,aws_secret_access_key)
def test_set_region_valid(self, m_boto):
# Make sure internal state is set and shared
m_regions = [
mocked_region('us-east-1'),
mocked_region('eu-west-1'),
]
m_boto.dynamodb.regions.return_value = m_regions
borg1 = ConnectionBorg()
borg2 = ConnectionBorg()
self.assertIs(None, borg1._region)
self.assertIs(None, borg2._region)
borg1.set_region("eu-west-1")
self.assertIs(m_regions[1], borg1._region)
self.assertIs(m_regions[1], borg2._region)
def test_get_table_default(self, m_boto):
m_get_table = m_boto.connect_dynamodb.return_value.get_table
aws_access_key_id = "foo"
aws_secret_access_key = "bar"
table_name = "foo"
borg1 = ConnectionBorg()
borg1._aws_access_key_id = aws_access_key_id
borg1._aws_secret_access_key = aws_secret_access_key
ConnectionBorg().get_table(table_name)
m_get_table.assert_called_with(table_name)
m_boto.connect_dynamodb.assert_called_with(
aws_access_key_id=aws_access_key_id,
aws_secret_access_key=aws_secret_access_key,
region=None,
)
def test_get_table_eu_region(self, m_boto):
m_get_table = m_boto.connect_dynamodb.return_value.get_table
m_region = mocked_region('eu-west-1')
aws_access_key_id = "foo"
aws_secret_access_key = "bar"
table_name = "foo"
borg1 = ConnectionBorg()
borg1._region = m_region
borg1._aws_access_key_id = aws_access_key_id
borg1._aws_secret_access_key = aws_secret_access_key
ConnectionBorg().get_table(table_name)
m_get_table.assert_called_with(table_name)
m_boto.connect_dynamodb.assert_called_with(
aws_access_key_id=aws_access_key_id,
aws_secret_access_key=aws_secret_access_key,
region=m_region,
)
import sys, re
from dynamodb_mapper.model import ConnectionBorg
from boto.dynamodb.exceptions import DynamoDBKeyNotFoundError
import settings
from digram import Digram
cb = ConnectionBorg()
cb.set_region('eu-west-1')
cb.set_credentials(settings.aws_access_key_id, settings.aws_secret_access_key)
for line in open(sys.argv[1], 'r'):
# find words
ws = filter(lambda match: match != '',
re.findall(r"$| ([a-zA-Z-']+)", line.encode('utf-8')))
# turn into lower case words
ws = map(lambda word: word.lower(), ws)
# digrams please
digrams = reduce(lambda dis, w: dis + [(dis[-1][1], w)], ws, [('','')])[2:]
print "found digrams: " + str(digrams)
for di in digrams:
try:
d_rec = Digram.get(di[0], di[1])
except DynamoDBKeyNotFoundError:
d_rec = Digram()
d_rec.w1 = di[0]
d_rec.w2 = di[1]
from dynamodb_mapper.model import DynamoDBModel
from dynamodb_mapper.model import ConnectionBorg
from django.db import models
#from settings import MEDIA_ROOT
from boto.dynamodb import condition
from django.db.models.signals import post_save
from django.contrib.auth.models import User
conn = ConnectionBorg()
conn.set_region('us-west-2')
class Books(DynamoDBModel):
__table__ = u"Books"
__hash_key__ = u"bookID"
__schema__ = {
u"bookID": unicode,
u"title": unicode,
}
def __unicode__(self):
return self.title
def num_quest(self):
return len(list(Questions.scan({"bookID":condition.EQ(self.bookID)})))
class Questions(DynamoDBModel):
__table__ = u"Questions"
__hash_key__ = u"questionID"
__schema__ = {
u"questionID": unicode,
u"bookID": unicode,
u"question": unicode,
def createTables(request):
conn = ConnectionBorg()
conn.create_table(models.Campground, 1, 1, wait_for_active=True)
#conn.create_table(models.Park, 1, 1, wait_for_active=True)
#conn.create_table(models.Review, 1, 1, wait_for_active=True)
return HttpResponse("Tables created")
__hash_key__=u"episode"
__range_key__=u"map"
__schema__={
u"episode": int,
u"map": int,
u"name"ll
: unicode,
u"cheats": set,
}
__defaults__={
"cheats": set([u"Konami"]),
}
if __name__ == "__main__":
conn = ConnectionBorg()
conn.create_table(DoomMap, 10, 10, wait_for_active=True)
e1m1 = DoomMap()
e1m1.episode = 1
e1m1.map = 1
e1m1.name = u"Hangar"
e1m1.cheats = set([u"idkfa", u"iddqd", u"idclip"])
e1m1.save()
# Later on, retrieve that same object from the DB...
e1m1 = DoomMap.get(1, 1)
# query all maps of episode 1
e1_maps = DoomMap.query(1)
def createTables(request):
conn = ConnectionBorg()
conn.create_table(models.Campground, 1, 1, wait_for_active=True)
#conn.create_table(models.Park, 1, 1, wait_for_active=True)
#conn.create_table(models.Review, 1, 1, wait_for_active=True)
return HttpResponse("Tables created")
def __init__(self, **kwargs):
conn = boto.connect_dynamodb()
super(EC2LoadBalancer, self).__init__(**kwargs)
if self.__table__ not in conn.list_tables():
conn = ConnectionBorg()
conn.create_table(self, 10, 10, wait_for_active=True)
import boto import dynamodb_mapper from dynamodb_mapper.model import DynamoDBModel from dynamodb_mapper.model import ConnectionBorg from ddbmock import config from ddbmock import connect_boto_patch from db_models import TestMap # mock config.STORAGE_ENGINE_NAME = 'sqlite' # switch to sqlite backend config.STORAGE_SQLITE_FILE = '/tmp/pyrest.sqlite' # define the database path. defaults to 'dynamo.db' db = connect_boto_patch() # Wire-up boto and ddbmock together # connect conn = ConnectionBorg() # create table conn.create_table(TestMap, 10, 10, False)
import requests
from dynamodb_mapper.model import DynamoDBModel
from dynamodb_mapper.model import ConnectionBorg
class LinkMap(DynamoDBModel):
__table__ = "links"
__hash_key__ = "from_link"
__schema__ = {
"from_link": unicode,
"to_link": unicode
}
try:
conn = ConnectionBorg()
conn.create_table(LinkMap, 5, 5, wait_for_active=True)
except:
pass
app = Flask(__name__)
@app.route('/', methods=['POST', 'GET'])
def hello_world():
if request.method == 'POST':
link = request.form['link']
try:
resolved_link = requests.get(link)
resolved_link.raise_for_status()
