srieger
/
cloud-computing-msc-ai-examples
1
2
Fork 1
Code Issues Pull Requests 1 Releases Wiki Activity
Browse Source

Converted all other files into python 3 using 2to3 lib

pull/3/head
Usama Tahir 1 year ago
parent
9a998ad631
commit
3b0062a84b
15 changed files with 623 additions and 9 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      faafo/bin/faafo
  2. 52
      faafo/bin/faafo-worker.bak
  3. 267
      faafo/bin/faafo.bak
  4. 6
      faafo/contrib/test_api.py
  5. 56
      faafo/contrib/test_api.py.bak
  6. 4
      faafo/doc/source/conf.py
  7. 17
      faafo/doc/source/conf.py.bak
  8. 0
      faafo/faafo/__init__.py.bak
  9. 0
      faafo/faafo/api/__init__.py.bak
  10. 6
      faafo/faafo/api/service.py
  11. 146
      faafo/faafo/api/service.py.bak
  12. 32
      faafo/faafo/queues.py.bak
  13. 15
      faafo/faafo/version.py.bak
  14. 0
      faafo/faafo/worker/__init__.py.bak
  15. 29
      faafo/setup.py.bak

2
faafo/bin/faafo
View File

@ -161,7 +161,7 @@ def do_create_fractal():
number = random.randint(int(CONF.command.min_tasks),
int(CONF.command.max_tasks))
LOG.info("generating %d task(s)" % number)
for i in xrange(0, number):
for i in range(0, number):
task = get_random_task()
LOG.debug("created task %s" % task)
# NOTE(berendt): only necessary when using requests < 2.4.2

52
faafo/bin/faafo-worker.bak
View File

@ -0,0 +1,52 @@
#!/usr/bin/env python
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import os
import sys
import kombu
from oslo_config import cfg
from oslo_log import log
from faafo.worker import service as worker
from faafo import version
LOG = log.getLogger('faafo.worker')
CONF = cfg.CONF
# If ../faafo/__init__.py exists, add ../ to Python search path, so that
# it will override what happens to be installed in /usr/(local/)lib/python...
possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
os.pardir,
os.pardir))
if os.path.exists(os.path.join(possible_topdir, 'faafo', '__init__.py')):
sys.path.insert(0, possible_topdir)
if __name__ == '__main__':
log.register_options(CONF)
log.set_defaults()
CONF(project='worker', prog='faafo-worker',
default_config_files=['/etc/faafo/faafo.conf'],
version=version.version_info.version_string())
log.setup(CONF, 'worker',
version=version.version_info.version_string())
connection = kombu.Connection(CONF.transport_url)
server = worker.Worker(connection)
try:
server.run()
except KeyboardInterrupt:
LOG.info("Caught keyboard interrupt. Exiting.")

267
faafo/bin/faafo.bak
View File

@ -0,0 +1,267 @@
#!/usr/bin/env python
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import copy
import json
import random
import uuid
from oslo_config import cfg
from oslo_log import log
from prettytable import PrettyTable
import requests
from faafo import version
LOG = log.getLogger('faafo.client')
CONF = cfg.CONF
def get_random_task():
random.seed()
if CONF.command.width:
width = int(CONF.command.width)
else:
width = random.randint(int(CONF.command.min_width),
int(CONF.command.max_width))
if CONF.command.height:
height = int(CONF.command.height)
else:
height = random.randint(int(CONF.command.min_height),
int(CONF.command.max_height))
if CONF.command.iterations:
iterations = int(CONF.command.iterations)
else:
iterations = random.randint(int(CONF.command.min_iterations),
int(CONF.command.max_iterations))
if CONF.command.xa:
xa = float(CONF.command.xa)
else:
xa = random.uniform(float(CONF.command.min_xa),
float(CONF.command.max_xa))
if CONF.command.xb:
xb = float(CONF.command.xb)
else:
xb = random.uniform(float(CONF.command.min_xb),
float(CONF.command.max_xb))
if CONF.command.ya:
ya = float(CONF.command.ya)
else:
ya = random.uniform(float(CONF.command.min_ya),
float(CONF.command.max_ya))
if CONF.command.yb:
yb = float(CONF.command.yb)
else:
yb = random.uniform(float(CONF.command.min_yb),
float(CONF.command.max_yb))
task = {
'uuid': str(uuid.uuid4()),
'width': width,
'height': height,
'iterations': iterations, 'xa': xa,
'xb': xb,
'ya': ya,
'yb': yb
}
return task
def do_get_fractal():
LOG.error("command 'download' not yet implemented")
def do_show_fractal():
LOG.info("showing fractal %s" % CONF.command.uuid)
result = requests.get("%s/v1/fractal/%s" %
(CONF.endpoint_url, CONF.command.uuid))
if result.status_code == 200:
data = json.loads(result.text)
output = PrettyTable(["Parameter", "Value"])
output.align["Parameter"] = "l"
output.align["Value"] = "l"
output.add_row(["uuid", data['uuid']])
output.add_row(["duration", "%f seconds" % data['duration']])
output.add_row(["dimensions", "%d x %d pixels" %
(data['width'], data['height'])])
output.add_row(["iterations", data['iterations']])
output.add_row(["xa", data['xa']])
output.add_row(["xb", data['xb']])
output.add_row(["ya", data['ya']])
output.add_row(["yb", data['yb']])
output.add_row(["size", "%d bytes" % data['size']])
output.add_row(["checksum", data['checksum']])
output.add_row(["generated_by", data['generated_by']])
print(output)
else:
LOG.error("fractal '%s' not found" % CONF.command.uuid)
def do_list_fractals():
LOG.info("listing all fractals")
fractals = get_fractals()
output = PrettyTable(["UUID", "Dimensions", "Filesize"])
for fractal in fractals:
output.add_row([
fractal["uuid"],
"%d x %d pixels" % (fractal["width"], fractal["height"]),
"%d bytes" % (fractal["size"] or 0),
])
print(output)
def get_fractals(page=1):
result = requests.get("%s/v1/fractal?page=%d" %
(CONF.endpoint_url, page))
fractals = []
if result.status_code == 200:
data = json.loads(result.text)
if page < data['total_pages']:
fractals = data['objects'] + get_fractals(page + 1)
else:
return data['objects']
return fractals
def do_delete_fractal():
LOG.info("deleting fractal %s" % CONF.command.uuid)
result = requests.delete("%s/v1/fractal/%s" %
(CONF.endpoint_url, CONF.command.uuid))
LOG.debug("result: %s" %result)
def do_create_fractal():
random.seed()
if CONF.command.tasks:
number = int(CONF.command.tasks)
else:
number = random.randint(int(CONF.command.min_tasks),
int(CONF.command.max_tasks))
LOG.info("generating %d task(s)" % number)
for i in xrange(0, number):
task = get_random_task()
LOG.debug("created task %s" % task)
# NOTE(berendt): only necessary when using requests < 2.4.2
headers = {'Content-type': 'application/json',
'Accept': 'text/plain'}
requests.post("%s/v1/fractal" % CONF.endpoint_url,
json.dumps(task), headers=headers)
def add_command_parsers(subparsers):
parser = subparsers.add_parser('create')
parser.set_defaults(func=do_create_fractal)
parser.add_argument("--height", default=None,
help="The height of the generate image.")
parser.add_argument("--min-height", default=256,
help="The minimum height of the generate image.")
parser.add_argument("--max-height", default=1024,
help="The maximum height of the generate image.")
parser.add_argument("--width", default=None,
help="The width of the generated image.")
parser.add_argument("--min-width", default=256,
help="The minimum width of the generated image.")
parser.add_argument("--max-width", default=1024,
help="The maximum width of the generated image.")
parser.add_argument("--iterations", default=None,
help="The number of iterations.")
parser.add_argument("--min-iterations", default=128,
help="The minimum number of iterations.")
parser.add_argument("--max-iterations", default=512,
help="The maximum number of iterations.")
parser.add_argument("--tasks", default=None,
help="The number of generated fractals.")
parser.add_argument("--min-tasks", default=1,
help="The minimum number of generated fractals.")
parser.add_argument("--max-tasks", default=10,
help="The maximum number of generated fractals.")
parser.add_argument("--xa", default=None,
help="The value for the parameter 'xa'.")
parser.add_argument("--min-xa", default=-1.0,
help="The minimum value for the parameter 'xa'.")
parser.add_argument("--max-xa", default=-4.0,
help="The maximum value for the parameter 'xa'.")
parser.add_argument("--xb", default=None,
help="The value for the parameter 'xb'.")
parser.add_argument("--min-xb", default=1.0,
help="The minimum value for the parameter 'xb'.")
parser.add_argument("--max-xb", default=4.0,
help="The maximum value for the parameter 'xb'.")
parser.add_argument("--ya", default=None,
help="The value for the parameter 'ya'.")
parser.add_argument("--min-ya", default=-0.5,
help="The minimum value for the parameter 'ya'.")
parser.add_argument("--max-ya", default=-3,
help="The maximum value for the parameter 'ya'.")
parser.add_argument("--yb", default=None,
help="The value for the parameter 'yb'.")
parser.add_argument("--min-yb", default=0.5,
help="The minimum value for the parameter 'yb'.")
parser.add_argument("--max-yb", default=3,
help="The maximum value for the parameter 'yb'.")
parser = subparsers.add_parser('delete')
parser.set_defaults(func=do_delete_fractal)
parser.add_argument("uuid", help="Fractal to delete.")
parser = subparsers.add_parser('show')
parser.set_defaults(func=do_show_fractal)
parser.add_argument("uuid", help="Fractal to show.")
parser = subparsers.add_parser('get')
parser.set_defaults(func=do_get_fractal)
parser.add_argument("uuid", help="Fractal to download.")
parser = subparsers.add_parser('list')
parser.set_defaults(func=do_list_fractals)
client_commands = cfg.SubCommandOpt('command', title='Commands',
help='Show available commands.',
handler=add_command_parsers)
CONF.register_cli_opts([client_commands])
client_cli_opts = [
cfg.StrOpt('endpoint-url',
default='http://localhost',
help='API connection URL')
]
CONF.register_cli_opts(client_cli_opts)
if __name__ == '__main__':
log.register_options(CONF)
log.set_defaults()
CONF(project='client', prog='faafo-client',
version=version.version_info.version_string())
log.setup(CONF, 'client',
version=version.version_info.version_string())
CONF.command.func()

6
faafo/contrib/test_api.py
View File

@ -34,11 +34,11 @@ assert response.status_code == 201
response = requests.get(url, headers=headers)
assert response.status_code == 200
print(response.json())
print((response.json()))
response = requests.get(url + '/' + uuid, headers=headers)
assert response.status_code == 200
print(response.json())
print((response.json()))
data = {
'checksum': 'c6fef4ef13a577066c2281b53c82ce2c7e94e',
@ -50,7 +50,7 @@ assert response.status_code == 200
response = requests.get(url + '/' + uuid, headers=headers)
assert response.status_code == 200
print(response.json())
print((response.json()))
response = requests.delete(url + '/' + uuid, headers=headers)
assert response.status_code == 204

56
faafo/contrib/test_api.py.bak
View File

@ -0,0 +1,56 @@
#!/usr/bin/env python
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import json
import requests
url = 'http://127.0.0.1/api/fractal'
headers = {'Content-Type': 'application/json'}
uuid = '13bf15a8-9f6c-4d59-956f-7d20f7484687'
data = {
'uuid': uuid,
'width': 100,
'height': 100,
'iterations': 10,
'xa': 1.0,
'xb': -1.0,
'ya': 1.0,
'yb': -1.0,
}
response = requests.post(url, data=json.dumps(data), headers=headers)
assert response.status_code == 201
response = requests.get(url, headers=headers)
assert response.status_code == 200
print(response.json())
response = requests.get(url + '/' + uuid, headers=headers)
assert response.status_code == 200
print(response.json())
data = {
'checksum': 'c6fef4ef13a577066c2281b53c82ce2c7e94e',
'duration': 10.12
}
response = requests.put(url + '/' + uuid, data=json.dumps(data),
headers=headers)
assert response.status_code == 200
response = requests.get(url + '/' + uuid, headers=headers)
assert response.status_code == 200
print(response.json())
response = requests.delete(url + '/' + uuid, headers=headers)
assert response.status_code == 204

4
faafo/doc/source/conf.py
View File

@ -11,7 +11,7 @@
# See the License for the specific language governing permissions and
# limitations under the License.
copyright = u'2015, OpenStack contributors'
copyright = '2015, OpenStack contributors'
master_doc = 'index'
project = u'First App Application for OpenStack'
project = 'First App Application for OpenStack'
source_suffix = '.rst'

17
faafo/doc/source/conf.py.bak
View File

@ -0,0 +1,17 @@
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
# implied.
# See the License for the specific language governing permissions and
# limitations under the License.
copyright = u'2015, OpenStack contributors'
master_doc = 'index'
project = u'First App Application for OpenStack'
source_suffix = '.rst'

0
faafo/faafo/__init__.py.bak
View File

0
faafo/faafo/api/__init__.py.bak
View File

6
faafo/faafo/api/service.py
View File

@ -12,7 +12,7 @@
import base64
import copy
import cStringIO
import io
from pkg_resources import resource_filename
import flask
@ -119,8 +119,8 @@ def get_fractal(fractalid):
response.status_code = 404
else:
image_data = base64.b64decode(fractal.image)
image = Image.open(cStringIO.StringIO(image_data))
output = cStringIO.StringIO()
image = Image.open(io.StringIO(image_data))
output = io.StringIO()
image.save(output, "PNG")
image.seek(0)
response = flask.make_response(output.getvalue())

146
faafo/faafo/api/service.py.bak
View File

@ -0,0 +1,146 @@
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import base64
import copy
import cStringIO
from pkg_resources import resource_filename
import flask
from flask_restless import APIManager
from flask_sqlalchemy import SQLAlchemy
from flask_bootstrap import Bootstrap
from kombu import Connection
from kombu.pools import producers
from oslo_config import cfg
from oslo_log import log
from PIL import Image
from sqlalchemy.dialects import mysql
from faafo import queues
from faafo import version
LOG = log.getLogger('faafo.api')
CONF = cfg.CONF
api_opts = [
cfg.StrOpt('listen-address',
default='0.0.0.0',
help='Listen address.'),
cfg.IntOpt('bind-port',
default='80',
help='Bind port.'),
cfg.StrOpt('database-url',
default='sqlite:////tmp/sqlite.db',
help='Database connection URL.')
]
CONF.register_opts(api_opts)
log.register_options(CONF)
log.set_defaults()
CONF(project='api', prog='faafo-api',
default_config_files=['/etc/faafo/faafo.conf'],
version=version.version_info.version_string())
log.setup(CONF, 'api',
version=version.version_info.version_string())
template_path = resource_filename(__name__, "templates")
app = flask.Flask('faafo.api', template_folder=template_path)
app.config['DEBUG'] = CONF.debug
app.config['SQLALCHEMY_DATABASE_URI'] = CONF.database_url
db = SQLAlchemy(app)
Bootstrap(app)
def list_opts():
"""Entry point for oslo-config-generator."""
return [(None, copy.deepcopy(api_opts))]
class Fractal(db.Model):
uuid = db.Column(db.String(36), primary_key=True)
checksum = db.Column(db.String(256), unique=True)
url = db.Column(db.String(256), nullable=True)
duration = db.Column(db.Float)
size = db.Column(db.Integer, nullable=True)
width = db.Column(db.Integer, nullable=False)
height = db.Column(db.Integer, nullable=False)
iterations = db.Column(db.Integer, nullable=False)
xa = db.Column(db.Float, nullable=False)
xb = db.Column(db.Float, nullable=False)
ya = db.Column(db.Float, nullable=False)
yb = db.Column(db.Float, nullable=False)
if CONF.database_url.startswith('mysql'):
LOG.debug('Using MySQL database backend')
image = db.Column(mysql.MEDIUMBLOB, nullable=True)
else:
image = db.Column(db.LargeBinary, nullable=True)
generated_by = db.Column(db.String(256), nullable=True)
def __repr__(self):
return '<Fractal %s>' % self.uuid
db.create_all()
manager = APIManager(app, flask_sqlalchemy_db=db)
connection = Connection(CONF.transport_url)
@app.route('/', methods=['GET'])
@app.route('/index', methods=['GET'])
@app.route('/index/<int:page>', methods=['GET'])
def index(page=1):
fractals = Fractal.query.filter(
(Fractal.checksum != None) & (Fractal.size != None)).paginate( # noqa
page, 5, error_out=False)
return flask.render_template('index.html', fractals=fractals)
@app.route('/fractal/<string:fractalid>', methods=['GET'])
def get_fractal(fractalid):
fractal = Fractal.query.filter_by(uuid=fractalid).first()
if not fractal:
response = flask.jsonify({'code': 404,
'message': 'Fracal not found'})
response.status_code = 404
else:
image_data = base64.b64decode(fractal.image)
image = Image.open(cStringIO.StringIO(image_data))
output = cStringIO.StringIO()
image.save(output, "PNG")
image.seek(0)
response = flask.make_response(output.getvalue())
response.content_type = "image/png"
return response
def generate_fractal(**kwargs):
with producers[connection].acquire(block=True) as producer:
producer.publish(kwargs['result'],
serializer='json',
exchange=queues.task_exchange,
declare=[queues.task_exchange],
routing_key='normal')
def main():
manager.create_api(Fractal, methods=['GET', 'POST', 'DELETE', 'PUT'],
postprocessors={'POST': [generate_fractal]},
exclude_columns=['image'],
url_prefix='/v1')
app.run(host=CONF.listen_address, port=CONF.bind_port)

32
faafo/faafo/queues.py.bak
View File

@ -0,0 +1,32 @@
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import copy
import kombu
from oslo_config import cfg
task_exchange = kombu.Exchange('tasks', type='direct')
task_queue = kombu.Queue('normal', task_exchange, routing_key='normal')
queues_opts = [
cfg.StrOpt('transport-url',
default='amqp://guest:guest@localhost:5672//',
help='AMQP connection URL.')
]
cfg.CONF.register_opts(queues_opts)
def list_opts():
"""Entry point for oslo-config-generator."""
return [(None, copy.deepcopy(queues_opts))]

15
faafo/faafo/version.py.bak
View File

@ -0,0 +1,15 @@
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import pbr.version
version_info = pbr.version.VersionInfo('faafo')

0
faafo/faafo/worker/__init__.py.bak
View File

29
faafo/setup.py.bak
View File

@ -0,0 +1,29 @@
#!/usr/bin/env python
# Copyright (c) 2013 Hewlett-Packard Development Company, L.P.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
# implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import setuptools
# In python < 2.7.4, a lazy loading of package `pbr` will break
# setuptools if some other modules registered functions in `atexit`.
# solution from: http://bugs.python.org/issue15881#msg170215
try:
import multiprocessing # noqa
except ImportError:
pass
setuptools.setup(
setup_requires=['pbr'],
pbr=True)
Write Preview
Loading…
Cancel
Save