def __init__(self, key, access, cluster): try: url = "http://169.254.169.254/latest/meta-data/" public_hostname = urlopen(url + "public-hostname").read() zone = urlopen(url + "placement/availability-zone").read() region = zone[:-1] except: sys.exit("We should be getting user-data here...") #us-east-1 breaks the convention. See http://docs.amazonwebservices.com/general/latest/gr/rande.html#sdb_region endpoint = "sdb.{0}.amazonaws.com".format(region) if region != "us-east-1" \ else "sdb.amazonaws.com" region_info = RegionInfo(name=region, endpoint=endpoint) sdb = SDBConnection(key, access, region=region_info) self.domain = sdb.create_domain(cluster) self.metadata = self.domain.get_item('metadata', consistent_read=True) if None == self.metadata: self.metadata = self.domain.new_item('metadata') self.metadata.add_value('master', '') self.metadata.add_value('slave', '') self.metadata.save()
def __init__(self, api=MongoStampedAPI(), logsQuery=logsQuery()): self.stamp_collection = api._stampDB._collection self.acct_collection = api._userDB._collection self.query = logsQuery self.writer = statWriter("dashboard") conn = SDBConnection(keys.aws.AWS_ACCESS_KEY_ID, keys.aws.AWS_SECRET_KEY) self.domain = conn.get_domain("dashboard")
def get_latest_snapshot(key, access, name): sdb = SDBConnection(key, access, region=region_info) domain = sdb.lookup(name, True) if domain == None: domain = sdb.create_domain(name) return domain.get_item('snapshot', True)['snapshot']
def delete_snapshot(key, access, name, snapshot_id): sdb = SDBConnection(key, access, region=region_info) domain = sdb.lookup(name, True) if domain == None: domain = sdb.create_domain(name) return domain.delete_item(domain.get_item(snapshot_id))
def get_all_snapshots(key, access, cluster): sdb = SDBConnection(key, access, region=region_info) domain = sdb.create_domain(cluster) now = strftime("%Y-%m-%d %H:%M:%S", gmtime()) select = "select * from `{0}` where itemName() > 'snap-' and itemName() != 'snapshot'".format(cluster) snapshots = domain.select(select, consistent_read=True) return snapshots
def get_latest_snapshot(key, access, cluster): sdb = SDBConnection(key, access, region=region_info) domain = sdb.create_domain(cluster) try: return domain.get_item('snapshot', True)['snapshot'] except: return None
def set_RDB(key, access, cluster, location): sdb = SDBConnection(key, access, region=region_info) domain = sdb.create_domain(cluster) # add the latest rdb (for automatic restores) latest = domain.new_item('rdb') latest.add_value('rdb', location) # get the expiration date from the object name (for comparison) latest.add_value('created', strftime("%Y-%m-%d %H:%M:%S", gmtime())) latest.save()
def SDB(domain_name): """ Create connection to SimpleDB and return the specifed domain. domain_name - the SimpleDB domain you wish to return """ conn = SDBConnection(ACCESS_KEY_ID,SECRET_ACCESS_KEY) domain = conn.lookup(domain_name) if not domain: domain = conn.create_domain(domain_name) return domain
def get_expired_snapshots(key, access, name): sdb = SDBConnection(key, access, region=region_info) domain = sdb.lookup(name, True) if domain == None: domain = sdb.create_domain(name) now = strftime("%Y-%m-%d %H:%M:%S", gmtime()) select = "select * from `{0}` where itemName() > 'snap-' and itemName() != 'snapshot' and expires < '{1}'".format(name, now) print select snapshots = domain.select(select, consistent_read=True) return snapshots
def get_all_snapshots(key, access, name): sdb = SDBConnection(key, access, region=region_info) domain = sdb.lookup(name, True) if domain == None: domain = sdb.create_domain(name) now = strftime("%Y-%m-%d %H:%M:%S", gmtime()) select = "select * from `{0}` where itemName() > 'snap-' and itemName() != 'snapshot'".format( name) snapshots = domain.select(select, consistent_read=True) return snapshots
def get_expired_snapshots(key, access, cluster): sdb = SDBConnection(key, access, region=region_info) domain = sdb.lookup(cluster, True) if domain == None: domain = sdb.create_domain(cluster) now = strftime("%Y-%m-%d %H:%M:%S", gmtime()) select = "select * from `{0}` where itemName() > 'snap-' and itemName() != 'snapshot' and expires < '{1}'".format( cluster, now) snapshots = domain.select(select, consistent_read=True) return snapshots
def get_identity(key, access, cluster): sdb = SDBConnection(key, access, region=region_info) domain = sdb.create_domain(cluster) slave_id = hashlib.md5(public_hostname).hexdigest()[:8] slave_fqdn = "{0}.{1}".format(slave_id, cluster) slave = domain.new_item(slave_fqdn) slave.add_value('id', slave_id) slave.add_value('endpoint', public_hostname) slave.save() return slave_fqdn
def submit(): if len(sys.argv) < 3: print "Usage:" print " %s -seed <seed> [<spawn coords>]" % sys.argv[0] return # TODO use less crappy command line parsing seed = sys.argv[2] if len(sys.argv) == 4: spawn = [int(x) for x in sys.argv[3].split(",")] assert(len(spawn) == 3) print "Generate world with this seed (\"%s\") with spawn %r [y/N]?" % (seed, spawn) else: spawn = None print "Generate world with this seed (\"%s\") [y/N]?" % seed if raw_input().lower() == 'y': uid = uuid.uuid4() print "Submitting job %s to queue..." % uid sqs = SQSConnection() sdb = SDBConnection() queue = sqs.get_queue("overviewer-genfromseed") db = sdb.get_domain("overviewerdb") print queue print db data = dict() data['uuid'] = str(uid) data['seed'] = seed data['generated'] = False if spawn: data['target_spawn'] = spawn if not db.put_attributes(uid, data): print "***Error: Failed to update the db" return 1 msg = Message() msg.set_body(str(uid)) if not queue.write(msg): print "***Error: Failed to enqueue" return 1 print "Ok, job enqueued" else: print "Ok, not submitting. Bye" return
class SimpleDBBackend: def __init__(self): self.connection = SDBConnection(aws_credentials.accessKey, aws_credentials.secretKey) self.domain = self.connection.get_domain(TABLE_NAME) def put(self, key, value): sampler.begin() try: self.domain.put_attributes(key, {VALUE:value}) finally: sampler.end() def get(self, key): sampler.begin() try: # First try an eventually consistent read. result = self.domain.get_attributes(key, consistent_read=False) return result[VALUE] except KeyError: # The eventually consistent read failed. Try a strongly consistent # read. result = self.domain.get_attributes(key, consistent_read=True) return result[VALUE] finally: sampler.end() def incRefCount(self, key): # Not implemented. pass def decRefCount(self, key): # Not implemented. pass def nuke(self): # Delete and re-create the table. self.connection.delete_domain(TABLE_NAME) self.domain = self.connection.create_domain(TABLE_NAME) def flush(self): pass # No-op.
def __init__(self, key, access, cluster): try: url = "http://169.254.169.254/latest/meta-data/" zone = urlopen(url + "placement/availability-zone").read() region = zone[:-1] except: sys.exit("We should be getting user-data here...") endpoint = "sdb.{0}.amazonaws.com".format(region) region_info = RegionInfo(name=region, endpoint=endpoint) sdb = SDBConnection(key, access, region=region_info) self.domain = sdb.create_domain(cluster) self.metadata = self.domain.get_item('metadata', consistent_read=True)
def add_snapshot(key, access, cluster, name, snapshot): sdb = SDBConnection(key, access, region=region_info) domain = sdb.lookup(cluster, True) if domain == None: domain = sdb.create_domain(cluster) now = strftime("%Y-%m-%d %H:%M:%S", gmtime()) # add the snapshot for expiration backup = domain.new_item(snapshot[0]) backup.add_value('name', name) backup.add_value('snapshot', snapshot[0]) backup.add_value('created', now) backup.add_value('expires', snapshot[1]) backup.save()
def add_snapshot(key, access, cluster, name, snapshot): sdb = SDBConnection(key, access, region=region_info) domain = sdb.lookup(cluster, True) if domain == None: domain = sdb.create_domain(cluster) now = strftime("%Y-%m-%d %H:%M:%S", gmtime()) # add the snapshot for expiration backup = domain.new_item(snapshot[0]) backup.add_value("name", name) backup.add_value("snapshot", snapshot[0]) backup.add_value("created", now) backup.add_value("expires", snapshot[1]) backup.save()
def get_latest_snapshot(key, access, cluster, name): sdb = SDBConnection(key, access, region=region_info) now = strftime("%Y-%m-%d %H:%M:%S", gmtime()) domain = sdb.lookup(cluster, True) if domain == None: domain = sdb.create_domain(cluster) select = "select * from `{0}` where name = '{1}' and created < '{2}' order by created desc limit 1".format( cluster, name, now) snapshots = domain.select(select, consistent_read=True) try: snapshot = snapshots.next() return snapshot['snapshot'] except: return None
def submit(): if len(sys.argv) < 3: print "Usage:" print " %s -submit <world uuid>" % sys.argv[0] return sdb = SDBConnection() db = sdb.get_domain("overviewerdb") # TODO use less crappy command line parsing world_uuid = uuid.UUID(sys.argv[2]) world_item = db.get_item(world_uuid) if not world_item: print "Can't find that world!" return 1 print "Submit this world for rendering? [y/N]" if raw_input().lower() != 'y': return "Ok, nevermind." return 0 from boto.sqs.connection import SQSConnection sqs = SQSConnection() queue = sqs.get_queue("overviewer-render") render_uuid = uuid.uuid4() print "Render UUID:", render_uuid data = dict() data['uuid'] = str(render_uuid) data['rendered'] = False data['world_uuid'] = str(world_uuid) if not db.put_attributes(str(render_uuid), data): print "***Error: Failed to update the db" return 1 msg = Message() msg.set_body(str(render_uuid)) if not queue.write(msg): print "***Error: Failed to enqueue" return 1 print "Ok, job enqueued" return 0
def __init__(self, stack): try: self.conn = SDBConnection(keys.aws.AWS_ACCESS_KEY_ID, keys.aws.AWS_SECRET_KEY) except SDBResponseError: print "SimpleDB Connection Refused" raise self._stack = stack
def set_cluster_metadata(key, access, cluster): sdb = SDBConnection(key, access, region=region_info) domain = sdb.create_domain(cluster) # set the basic values in the 'master' record metadata = domain.new_item('metadata') #master = "{0}.{1}".format( # os.environ['REDIS_NAME'].strip(), # os.environ['HOSTED_ZONE_NAME'].rstrip('.')) #metadata.add_value('master', master) try: if "" != os.environ['REDIS_SIZE'].strip(): metadata.add_value('size', os.environ['REDIS_SIZE']) except: pass try: if "" != os.environ['REDIS_PERSISTENCE'].strip(): metadata.add_value('persistence', os.environ['REDIS_PERSISTENCE']) else: metadata.add_value('persistence', 'no') except: metadata.add_value('persistence', 'no') try: if "" != os.environ['REDIS_SNAPSHOT'].strip(): metadata.add_value('snapshot', os.environ['REDIS_SNAPSHOT']) except: pass try: if "" != os.environ['REDIS_RDB'].strip(): metadata.add_value('rdb', os.environ['REDIS_RDB']) except: pass try: if "" != os.environ['REDIS_AOF'].strip(): metadata.add_value('aof', os.environ['REDIS_AOF']) except: pass metadata.save()
def get_latest_snapshot(key, access, cluster, name): sdb = SDBConnection(key, access, region=region_info) now = strftime("%Y-%m-%d %H:%M:%S", gmtime()) domain = sdb.lookup(cluster, True) if domain == None: domain = sdb.create_domain(cluster) select = "select * from `{0}` where name = '{1}' and created < '{2}' order by created desc limit 1".format( cluster, name, now ) snapshots = domain.select(select, consistent_read=True) try: snapshot = snapshots.next() return snapshot["snapshot"] except: return None
def __init__(self,api): self.api = api self.conn = SDBConnection(keys.aws.AWS_ACCESS_KEY_ID, keys.aws.AWS_SECRET_KEY) self.domains = {} self.statDict = {} for i in range (0,16): suffix = '0'+hex(i)[2] self.domains[suffix] = self.conn.get_domain('stats_dev_%s' % (suffix))
def __init__(self, domain=None): self.conn = SDBConnection(keys.aws.AWS_ACCESS_KEY_ID, keys.aws.AWS_SECRET_KEY) self.domain_name = None self.domains = {} if domain is None and is_ec2(): stack = get_stack() stack_name = str(stack['instance']['stack']) self.domain_name = stack_name elif domain is not None: self.domain_name = domain
def add_snapshot(key, access, name, snapshot): sdb = SDBConnection(key, access, region=region_info) domain = sdb.lookup(name, True) if domain == None: domain = sdb.create_domain(name) now = strftime("%Y-%m-%d %H:%M:%S", gmtime()) # add the snapshot for expiration backup = domain.new_item(snapshot[0]) backup.add_value('snapshot', snapshot[0]) backup.add_value('created', now) backup.add_value('expires', snapshot[1]) backup.save() # add the latest (for automatic restores) latest = domain.new_item('snapshot') latest.add_value('snapshot', snapshot[0]) latest.save()
def test_1_basic(self): print '--- running SDBConnection tests ---' c = SDBConnection() rs = c.get_all_domains() num_domains = len(rs) # try illegal name try: domain = c.create_domain('bad:domain:name') except SDBResponseError: pass # now create one that should work and should be unique (i.e. a new one) domain_name = 'test%d' % int(time.time()) domain = c.create_domain(domain_name) rs = c.get_all_domains() assert len(rs) == num_domains + 1 # now let's a couple of items and attributes item_1 = 'item1' same_value = 'same_value' attrs_1 = {'name1': same_value, 'name2': 'diff_value_1'} domain.put_attributes(item_1, attrs_1) item_2 = 'item2' attrs_2 = {'name1': same_value, 'name2': 'diff_value_2'} domain.put_attributes(item_2, attrs_2) time.sleep(10) # try to get the attributes and see if they match item = domain.get_attributes(item_1) assert len(item.keys()) == len(attrs_1.keys()) assert item['name1'] == attrs_1['name1'] assert item['name2'] == attrs_1['name2'] # try a search or two rs = domain.query("['name1'='%s']" % same_value) n = 0 for item in rs: n += 1 assert n == 2 rs = domain.query("['name2'='diff_value_2']") n = 0 for item in rs: n += 1 assert n == 1 # delete all attributes associated with item_1 stat = domain.delete_attributes(item_1) assert stat # now delete the domain stat = c.delete_domain(domain) assert stat print '--- tests completed ---'
def connect_sdb(aws_access_key_id=None, aws_secret_access_key=None, **kwargs): """ @type aws_access_key_id: string @param aws_access_key_id: Your AWS Access Key ID @type aws_secret_access_key: string @param aws_secret_access_key: Your AWS Secret Access Key @rtype: L{SDBConnection<boto.sdb.connection.SDBConnection>} @return: A connection to Amazon's SDB """ from boto.sdb.connection import SDBConnection return SDBConnection(aws_access_key_id, aws_secret_access_key, **kwargs)
def connect_sdb(aws_access_key_id=None, aws_secret_access_key=None, **kwargs): """ :type aws_access_key_id: string :param aws_access_key_id: Your AWS Access Key ID :type aws_secret_access_key: string :param aws_secret_access_key: Your AWS Secret Access Key :rtype: :class:`boto.sdb.connection.SDBConnection` :return: A connection to Amazon's SDB """ from boto.sdb.connection import SDBConnection return SDBConnection(aws_access_key_id, aws_secret_access_key, **kwargs)
def connect(self, **kw_params): """ Connect to this Region's endpoint. Returns an SDBConnection object pointing to the endpoint associated with this region. You may pass any of the arguments accepted by the SDBConnection object's constructor as keyword arguments and they will be passed along to the SDBConnection object. :rtype: :class:`boto.sdb.connection.SDBConnection` :return: The connection to this regions endpoint """ from boto.sdb.connection import SDBConnection return SDBConnection(region=self, **kw_params)
class statWriter(object): def __init__(self,domain=None): self.conn = SDBConnection(keys.aws.AWS_ACCESS_KEY_ID, keys.aws.AWS_SECRET_KEY) self.domain_name = domain def write(self,stat,key=None,domain=None): if domain is None: if self.domain_name is None: return False else: domain = self.domain_name if key is None: key = uuid.uuid1() if len(stat) > 0: try: domain = self.conn.get_domain(domain) except SDBResponseError: domain = self.conn.create_domain(domain) domain.put_attributes(key, stat, replace=False) return True
def add_from_url(): if len(sys.argv) < 3: print "Usage:" print " %s -url <url>" % sys.argv[0] return url = sys.argv[2] print "Generate world with this url (\"%s\") [y/N]?" % url if raw_input().lower() != 'y': print "Ok, nevermind" return uid = uuid.uuid4() data = dict() data['uuid'] = uid data['world_url'] = url sdb = SDBConnection() db = sdb.get_domain("overviewerdb") if not db.put_attributes(uid, data): print "***Error: Failed to update the db" return 1 print "Ok. DB updated" print uid
def add_snapshot(key, access, cluster, snapshot): sdb = SDBConnection(key, access, region=region_info) domain = sdb.create_domain(cluster) now = strftime("%Y-%m-%d %H:%M:%S", gmtime()) # add the latest rdb (for automatic restores) latest = domain.new_item('snapshot') latest.add_value('snapshot', snapshot[0]) # get the expiration date from the object name (for comparison) latest.add_value('created', now) latest.save() # add the snapshot for expiration backup = domain.new_item(snapshot[0]) backup.add_value('snapshot', snapshot[0]) backup.add_value('created', now) backup.add_value('expires', snapshot[1]) backup.save() # add the latest (for automatic restores) latest = domain.new_item('snapshot') latest.add_value('snapshot', snapshot[0]) latest.save()
def __init__(self,domain_name=None): self.conn = SDBConnection(keys.aws.AWS_ACCESS_KEY_ID, keys.aws.AWS_SECRET_KEY) self.domains = {} self.statSet = set() self.statDict = {} self.errDict = {} self.statCount = 0 self.statCountByNode = {} self.statTimeByNode = {} if domain_name is None: domain_name = 'stress' for i in range (0,16): suffix = '0'+hex(i)[2] self.domains[suffix] = self.conn.get_domain('%s_%s' % (domain_name,suffix))
def test_1_basic(self): print '--- running SDBConnection tests ---' c = SDBConnection() rs = c.get_all_domains() num_domains = len(rs) # try illegal name try: domain = c.create_domain('bad:domain:name') except SDBResponseError: pass # now create one that should work and should be unique (i.e. a new one) domain_name = 'test%d' % int(time.time()) domain = c.create_domain(domain_name) rs = c.get_all_domains() assert len(rs) == num_domains+1 # now let's a couple of items and attributes item_1 = 'item1' same_value = 'same_value' attrs_1 = {'name1' : same_value, 'name2' : 'diff_value_1'} domain.put_attributes(item_1, attrs_1) item_2 = 'item2' attrs_2 = {'name1' : same_value, 'name2' : 'diff_value_2'} domain.put_attributes(item_2, attrs_2) time.sleep(10) # try to get the attributes and see if they match item = domain.get_attributes(item_1) assert len(item.keys()) == len(attrs_1.keys()) assert item['name1'] == attrs_1['name1'] assert item['name2'] == attrs_1['name2'] # try a search or two rs = domain.query("['name1'='%s']" % same_value) n = 0 for item in rs: n += 1 assert n == 2 rs = domain.query("['name2'='diff_value_2']") n = 0 for item in rs: n += 1 assert n == 1 # delete all attributes associated with item_1 stat = domain.delete_attributes(item_1) assert stat # now delete the domain stat = c.delete_domain(domain) assert stat print '--- tests completed ---'
def __init__(self): try: self.conn = SDBConnection(keys.aws.AWS_ACCESS_KEY_ID, keys.aws.AWS_SECRET_KEY) except SDBResponseError: print "SimpleDB Connection Refused" self.statList = [] self.statCount = 0 self.v1_prod_domains = {} self.v2_prod_domains = {} self.v2_dev_domains = {} self.v2_stress_domains = {} for i in range (0,16): suffix = '0'+hex(i)[2] self.v1_prod_domains[suffix] = self.conn.get_domain('stats_prod_%s' % suffix) self.v2_prod_domains[suffix] = self.conn.get_domain('bowser_%s' % suffix) self.v2_dev_domains[suffix] = self.conn.get_domain('stats_dev_%s' % suffix) self.v2_stress_domains[suffix] = self.conn.get_domain('stress_%s' % suffix)
def __init__(self): self.connection = SDBConnection(aws_credentials.accessKey, aws_credentials.secretKey) self.domain = self.connection.get_domain(TABLE_NAME)
def test_1_basic(self): print '--- running SDBConnection tests ---' c = SDBConnection() rs = c.get_all_domains() num_domains = len(rs) # try illegal name try: domain = c.create_domain('bad:domain:name') except SDBResponseError: pass # now create one that should work and should be unique (i.e. a new one) domain_name = 'test%d' % int(time.time()) domain = c.create_domain(domain_name) rs = c.get_all_domains() assert len(rs) == num_domains + 1 # now let's a couple of items and attributes item_1 = 'item1' same_value = 'same_value' attrs_1 = {'name1' : same_value, 'name2' : 'diff_value_1'} domain.put_attributes(item_1, attrs_1) item_2 = 'item2' attrs_2 = {'name1' : same_value, 'name2' : 'diff_value_2'} domain.put_attributes(item_2, attrs_2) # try to get the attributes and see if they match item = domain.get_attributes(item_1, consistent_read=True) assert len(item.keys()) == len(attrs_1.keys()) assert item['name1'] == attrs_1['name1'] assert item['name2'] == attrs_1['name2'] # try a search or two query = 'select * from %s where name1="%s"' % (domain_name, same_value) rs = domain.select(query, consistent_read=True) n = 0 for item in rs: n += 1 assert n == 2 query = 'select * from %s where name2="diff_value_2"' % domain_name rs = domain.select(query, consistent_read=True) n = 0 for item in rs: n += 1 assert n == 1 # delete all attributes associated with item_1 stat = domain.delete_attributes(item_1) assert stat # now try a batch put operation on the domain item3 = {'name3_1' : 'value3_1', 'name3_2' : 'value3_2', 'name3_3' : ['value3_3_1', 'value3_3_2']} item4 = {'name4_1' : 'value4_1', 'name4_2' : ['value4_2_1', 'value4_2_2'], 'name4_3' : 'value4_3'} items = {'item3' : item3, 'item4' : item4} domain.batch_put_attributes(items) item = domain.get_attributes('item3', consistent_read=True) assert item['name3_2'] == 'value3_2' # now try a batch delete operation (variation #1) items = {'item3' : item3} stat = domain.batch_delete_attributes(items) item = domain.get_attributes('item3', consistent_read=True) assert not item # now try a batch delete operation (variation #2) stat = domain.batch_delete_attributes({'item4' : None}) item = domain.get_attributes('item4', consistent_read=True) assert not item # now delete the domain stat = c.delete_domain(domain) assert stat print '--- tests completed ---'
class SimpleDB(object): def __init__(self, domain=None): self.conn = SDBConnection(keys.aws.AWS_ACCESS_KEY_ID, keys.aws.AWS_SECRET_KEY) self.domain_name = None self.domains = {} if domain is None and is_ec2(): stack = get_stack() stack_name = str(stack['instance']['stack']) self.domain_name = stack_name elif domain is not None: self.domain_name = domain def addStat(self, stat): if self.domain_name is None: return try: # Only add specific parameters data = {} if 'user_id' in stat: data['uid'] = stat['user_id'] if 'path' in stat: data['uri'] = stat['path'] if 'method' in stat: data['mtd'] = stat['method'] if 'form' in stat: try: for k, v in stat['form'].items(): try: if not isinstance(v, basestring): v = str(v) if len(v.encode('utf-8')) > 1024: v = '<INPUT TOO LONG>' data['frm_%s' % k] = v except Exception as e: print e except Exception as e: print e if 'result' in stat: data['cde'] = str(stat['result']) if 'begin' in stat: data['bgn'] = stat['begin'].isoformat() if 'finish' in stat: data['end'] = stat['finish'].isoformat() if 'node' in stat: data['nde'] = stat['node'] if 'client_id' in stat: data['cid'] = stat['client_id'] if 'duration' in stat: data['dur'] = "{0:10d}".format(stat['duration']) if len(data) > 0: statId = str(ObjectId()) if data['uri'] != '/v1/ping.json' and data['uri'] != '/v1/temp/ping.json': suffix = '0%s' % (sha1(statId).hexdigest()[0]) if suffix in self.domains: domain = self.domains[suffix] else: try: domain = self.conn.get_domain('%s_%s' % (self.domain_name, suffix)) except SDBResponseError: domain = self.conn.create_domain('%s_%s' % (self.domain_name, suffix)) self.domains[suffix] = domain domain.put_attributes(statId, data, replace=False) except Exception as e: print e raise
#!/usr/bin/python2 import sys import os from pprint import pprint try: import boto except ImportError: sys.path.append(os.path.expanduser("~/devel/boto")) import boto from boto.sdb.connection import SDBConnection uid = sys.argv[1] print "Looking up", uid sdb = SDBConnection() db = sdb.get_domain("overviewerdb") data = db.get_item(uid) pprint(data)