prompt
large_stringlengths
72
9.34k
completion
large_stringlengths
0
7.61k
<|file_name|>exceptions.py<|end_file_name|><|fim▁begin|># TODO When raising an exception pass a lambda function, the function being the module/path/name thing ERROR = {'default': "Unknown engine error ({0})", 400: "Bad request sent to search API ({0})", 401: "Incorrect API Key ({0})", 403: "Correct API but request refused ({0})", 404: "Bad request sent to search API ({0})"} class SearchException(Exception): """ Abstract class representing an ifind search exception. """ def __init__(self, module, message): """ SearchException constructor. Args: module (str): name of module/class that's raising exception message (str): exception message to be displayed Usage: raise SearchException("Test", "this is an error") """ message = "{0} - {1}".format(module, message) Exception.__init__(self, message) class EngineConnectionException(SearchException): """ Thrown when an Engine connectivity error occurs. Returns specific response message if status code specified. """ def __init__(self, engine, message, code=None): """ EngineException constructor. Args: engine (str): name of engine that's raising exception message (str): exception message to be displayed (ignored usually here) Kwargs: code (int): response status code of issued request Usage: raise EngineException("Bing", "", code=200) """ self.message = message self.code = code if code: <|fim_middle|> SearchException.__init__(self, engine, self.message) class EngineLoadException(SearchException): """ Thrown when an Engine can't be dynamically loaded. """ pass class EngineAPIKeyException(SearchException): """ Thrown when an Engine's API key hasn't been provided. """ pass class QueryParamException(SearchException): """ Thrown when a query parameters incompatible or missing. """ pass class CacheConnectionException(SearchException): """ Thrown when cache connectivity error occurs. """ pass class InvalidQueryException(SearchException): """ Thrown when an invalid query is passed to engine's search method. """ pass class RateLimitException(SearchException): """ Thrown when an engine's request rate limit has been exceeded. """ pass<|fim▁end|>
self.message = ERROR.get(code, ERROR['default']).format(self.code)
<|file_name|>exceptions.py<|end_file_name|><|fim▁begin|># TODO When raising an exception pass a lambda function, the function being the module/path/name thing ERROR = {'default': "Unknown engine error ({0})", 400: "Bad request sent to search API ({0})", 401: "Incorrect API Key ({0})", 403: "Correct API but request refused ({0})", 404: "Bad request sent to search API ({0})"} class SearchException(Exception): """ Abstract class representing an ifind search exception. """ def <|fim_middle|>(self, module, message): """ SearchException constructor. Args: module (str): name of module/class that's raising exception message (str): exception message to be displayed Usage: raise SearchException("Test", "this is an error") """ message = "{0} - {1}".format(module, message) Exception.__init__(self, message) class EngineConnectionException(SearchException): """ Thrown when an Engine connectivity error occurs. Returns specific response message if status code specified. """ def __init__(self, engine, message, code=None): """ EngineException constructor. Args: engine (str): name of engine that's raising exception message (str): exception message to be displayed (ignored usually here) Kwargs: code (int): response status code of issued request Usage: raise EngineException("Bing", "", code=200) """ self.message = message self.code = code if code: self.message = ERROR.get(code, ERROR['default']).format(self.code) SearchException.__init__(self, engine, self.message) class EngineLoadException(SearchException): """ Thrown when an Engine can't be dynamically loaded. """ pass class EngineAPIKeyException(SearchException): """ Thrown when an Engine's API key hasn't been provided. """ pass class QueryParamException(SearchException): """ Thrown when a query parameters incompatible or missing. """ pass class CacheConnectionException(SearchException): """ Thrown when cache connectivity error occurs. """ pass class InvalidQueryException(SearchException): """ Thrown when an invalid query is passed to engine's search method. """ pass class RateLimitException(SearchException): """ Thrown when an engine's request rate limit has been exceeded. """ pass<|fim▁end|>
__init__
<|file_name|>exceptions.py<|end_file_name|><|fim▁begin|># TODO When raising an exception pass a lambda function, the function being the module/path/name thing ERROR = {'default': "Unknown engine error ({0})", 400: "Bad request sent to search API ({0})", 401: "Incorrect API Key ({0})", 403: "Correct API but request refused ({0})", 404: "Bad request sent to search API ({0})"} class SearchException(Exception): """ Abstract class representing an ifind search exception. """ def __init__(self, module, message): """ SearchException constructor. Args: module (str): name of module/class that's raising exception message (str): exception message to be displayed Usage: raise SearchException("Test", "this is an error") """ message = "{0} - {1}".format(module, message) Exception.__init__(self, message) class EngineConnectionException(SearchException): """ Thrown when an Engine connectivity error occurs. Returns specific response message if status code specified. """ def <|fim_middle|>(self, engine, message, code=None): """ EngineException constructor. Args: engine (str): name of engine that's raising exception message (str): exception message to be displayed (ignored usually here) Kwargs: code (int): response status code of issued request Usage: raise EngineException("Bing", "", code=200) """ self.message = message self.code = code if code: self.message = ERROR.get(code, ERROR['default']).format(self.code) SearchException.__init__(self, engine, self.message) class EngineLoadException(SearchException): """ Thrown when an Engine can't be dynamically loaded. """ pass class EngineAPIKeyException(SearchException): """ Thrown when an Engine's API key hasn't been provided. """ pass class QueryParamException(SearchException): """ Thrown when a query parameters incompatible or missing. """ pass class CacheConnectionException(SearchException): """ Thrown when cache connectivity error occurs. """ pass class InvalidQueryException(SearchException): """ Thrown when an invalid query is passed to engine's search method. """ pass class RateLimitException(SearchException): """ Thrown when an engine's request rate limit has been exceeded. """ pass<|fim▁end|>
__init__
<|file_name|>dialogs.py<|end_file_name|><|fim▁begin|># dialogs - provide common dialogs # # Copyright (c) 2006 FSF Europe # # Authors: # Sebastian Heinlein <[email protected]> # Michael Vogt <[email protected]> # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License as # published by the Free Software Foundation; either version 2 of the # License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 # USA from gi.repository import Gtk def show_error_dialog(parent, primary, secondary): p = "<span weight=\"bold\" size=\"larger\">%s</span>" % primary dialog = Gtk.MessageDialog(parent,Gtk.DialogFlags.MODAL, Gtk.MessageType.ERROR,Gtk.ButtonsType.CLOSE,"")<|fim▁hole|> dialog.format_secondary_text(secondary); dialog.run() dialog.hide()<|fim▁end|>
dialog.set_markup(p);
<|file_name|>dialogs.py<|end_file_name|><|fim▁begin|># dialogs - provide common dialogs # # Copyright (c) 2006 FSF Europe # # Authors: # Sebastian Heinlein <[email protected]> # Michael Vogt <[email protected]> # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License as # published by the Free Software Foundation; either version 2 of the # License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 # USA from gi.repository import Gtk def show_error_dialog(parent, primary, secondary): <|fim_middle|> <|fim▁end|>
p = "<span weight=\"bold\" size=\"larger\">%s</span>" % primary dialog = Gtk.MessageDialog(parent,Gtk.DialogFlags.MODAL, Gtk.MessageType.ERROR,Gtk.ButtonsType.CLOSE,"") dialog.set_markup(p); dialog.format_secondary_text(secondary); dialog.run() dialog.hide()
<|file_name|>dialogs.py<|end_file_name|><|fim▁begin|># dialogs - provide common dialogs # # Copyright (c) 2006 FSF Europe # # Authors: # Sebastian Heinlein <[email protected]> # Michael Vogt <[email protected]> # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License as # published by the Free Software Foundation; either version 2 of the # License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 # USA from gi.repository import Gtk def <|fim_middle|>(parent, primary, secondary): p = "<span weight=\"bold\" size=\"larger\">%s</span>" % primary dialog = Gtk.MessageDialog(parent,Gtk.DialogFlags.MODAL, Gtk.MessageType.ERROR,Gtk.ButtonsType.CLOSE,"") dialog.set_markup(p); dialog.format_secondary_text(secondary); dialog.run() dialog.hide() <|fim▁end|>
show_error_dialog
<|file_name|>equi_leader.py<|end_file_name|><|fim▁begin|>""" https://codility.com/programmers/task/equi_leader/ """<|fim▁hole|> def solution(A): def _is_equi_leader(i): prefix_count_top = running_counts[top] suffix_count_top = total_counts[top] - prefix_count_top return (prefix_count_top * 2 > i + 1) and (suffix_count_top * 2 > len(A) - i - 1) total_counts = Counter(A) running_counts = defaultdict(int) top = A[0] result = 0 for i in xrange(len(A) - 1): n = A[i] running_counts[n] += 1 top = top if running_counts[top] >= running_counts[n] else n if _is_equi_leader(i): result += 1 return result<|fim▁end|>
from collections import Counter, defaultdict
<|file_name|>equi_leader.py<|end_file_name|><|fim▁begin|>""" https://codility.com/programmers/task/equi_leader/ """ from collections import Counter, defaultdict def solution(A): <|fim_middle|> <|fim▁end|>
def _is_equi_leader(i): prefix_count_top = running_counts[top] suffix_count_top = total_counts[top] - prefix_count_top return (prefix_count_top * 2 > i + 1) and (suffix_count_top * 2 > len(A) - i - 1) total_counts = Counter(A) running_counts = defaultdict(int) top = A[0] result = 0 for i in xrange(len(A) - 1): n = A[i] running_counts[n] += 1 top = top if running_counts[top] >= running_counts[n] else n if _is_equi_leader(i): result += 1 return result
<|file_name|>equi_leader.py<|end_file_name|><|fim▁begin|>""" https://codility.com/programmers/task/equi_leader/ """ from collections import Counter, defaultdict def solution(A): def _is_equi_leader(i): <|fim_middle|> total_counts = Counter(A) running_counts = defaultdict(int) top = A[0] result = 0 for i in xrange(len(A) - 1): n = A[i] running_counts[n] += 1 top = top if running_counts[top] >= running_counts[n] else n if _is_equi_leader(i): result += 1 return result <|fim▁end|>
prefix_count_top = running_counts[top] suffix_count_top = total_counts[top] - prefix_count_top return (prefix_count_top * 2 > i + 1) and (suffix_count_top * 2 > len(A) - i - 1)
<|file_name|>equi_leader.py<|end_file_name|><|fim▁begin|>""" https://codility.com/programmers/task/equi_leader/ """ from collections import Counter, defaultdict def solution(A): def _is_equi_leader(i): prefix_count_top = running_counts[top] suffix_count_top = total_counts[top] - prefix_count_top return (prefix_count_top * 2 > i + 1) and (suffix_count_top * 2 > len(A) - i - 1) total_counts = Counter(A) running_counts = defaultdict(int) top = A[0] result = 0 for i in xrange(len(A) - 1): n = A[i] running_counts[n] += 1 top = top if running_counts[top] >= running_counts[n] else n if _is_equi_leader(i): <|fim_middle|> return result <|fim▁end|>
result += 1
<|file_name|>equi_leader.py<|end_file_name|><|fim▁begin|>""" https://codility.com/programmers/task/equi_leader/ """ from collections import Counter, defaultdict def <|fim_middle|>(A): def _is_equi_leader(i): prefix_count_top = running_counts[top] suffix_count_top = total_counts[top] - prefix_count_top return (prefix_count_top * 2 > i + 1) and (suffix_count_top * 2 > len(A) - i - 1) total_counts = Counter(A) running_counts = defaultdict(int) top = A[0] result = 0 for i in xrange(len(A) - 1): n = A[i] running_counts[n] += 1 top = top if running_counts[top] >= running_counts[n] else n if _is_equi_leader(i): result += 1 return result <|fim▁end|>
solution
<|file_name|>equi_leader.py<|end_file_name|><|fim▁begin|>""" https://codility.com/programmers/task/equi_leader/ """ from collections import Counter, defaultdict def solution(A): def <|fim_middle|>(i): prefix_count_top = running_counts[top] suffix_count_top = total_counts[top] - prefix_count_top return (prefix_count_top * 2 > i + 1) and (suffix_count_top * 2 > len(A) - i - 1) total_counts = Counter(A) running_counts = defaultdict(int) top = A[0] result = 0 for i in xrange(len(A) - 1): n = A[i] running_counts[n] += 1 top = top if running_counts[top] >= running_counts[n] else n if _is_equi_leader(i): result += 1 return result <|fim▁end|>
_is_equi_leader
<|file_name|>test_annotations.py<|end_file_name|><|fim▁begin|>from __future__ import absolute_import import matplotlib # Force matplotlib to not use any Xwindows backend. matplotlib.use('Agg') import matplotlib.pyplot as plt from plotly.tests.utils import compare_dict from plotly.tests.test_optional.optional_utils import run_fig from plotly.tests.test_optional.test_matplotlylib.data.annotations import * def test_annotations(): fig, ax = plt.subplots() ax.plot([1, 2, 3], 'b-') ax.plot([3, 2, 1], 'b-') ax.text(0.001, 0.999, 'top-left', transform=ax.transAxes, va='top', ha='left')<|fim▁hole|> ax.text(0.999, 0.999, 'top-right', transform=ax.transAxes, va='top', ha='right') ax.text(0.999, 0.001, 'bottom-right', transform=ax.transAxes, va='baseline', ha='right') renderer = run_fig(fig) for data_no, data_dict in enumerate(renderer.plotly_fig['data']): equivalent, msg = compare_dict(data_dict, ANNOTATIONS['data'][data_no]) assert equivalent, msg for no, note in enumerate(renderer.plotly_fig['layout']['annotations']): equivalent, msg = compare_dict(note, ANNOTATIONS['layout']['annotations'][no]) assert equivalent, msg<|fim▁end|>
ax.text(0.001, 0.001, 'bottom-left', transform=ax.transAxes, va='baseline', ha='left')
<|file_name|>test_annotations.py<|end_file_name|><|fim▁begin|>from __future__ import absolute_import import matplotlib # Force matplotlib to not use any Xwindows backend. matplotlib.use('Agg') import matplotlib.pyplot as plt from plotly.tests.utils import compare_dict from plotly.tests.test_optional.optional_utils import run_fig from plotly.tests.test_optional.test_matplotlylib.data.annotations import * def test_annotations(): <|fim_middle|> <|fim▁end|>
fig, ax = plt.subplots() ax.plot([1, 2, 3], 'b-') ax.plot([3, 2, 1], 'b-') ax.text(0.001, 0.999, 'top-left', transform=ax.transAxes, va='top', ha='left') ax.text(0.001, 0.001, 'bottom-left', transform=ax.transAxes, va='baseline', ha='left') ax.text(0.999, 0.999, 'top-right', transform=ax.transAxes, va='top', ha='right') ax.text(0.999, 0.001, 'bottom-right', transform=ax.transAxes, va='baseline', ha='right') renderer = run_fig(fig) for data_no, data_dict in enumerate(renderer.plotly_fig['data']): equivalent, msg = compare_dict(data_dict, ANNOTATIONS['data'][data_no]) assert equivalent, msg for no, note in enumerate(renderer.plotly_fig['layout']['annotations']): equivalent, msg = compare_dict(note, ANNOTATIONS['layout']['annotations'][no]) assert equivalent, msg
<|file_name|>test_annotations.py<|end_file_name|><|fim▁begin|>from __future__ import absolute_import import matplotlib # Force matplotlib to not use any Xwindows backend. matplotlib.use('Agg') import matplotlib.pyplot as plt from plotly.tests.utils import compare_dict from plotly.tests.test_optional.optional_utils import run_fig from plotly.tests.test_optional.test_matplotlylib.data.annotations import * def <|fim_middle|>(): fig, ax = plt.subplots() ax.plot([1, 2, 3], 'b-') ax.plot([3, 2, 1], 'b-') ax.text(0.001, 0.999, 'top-left', transform=ax.transAxes, va='top', ha='left') ax.text(0.001, 0.001, 'bottom-left', transform=ax.transAxes, va='baseline', ha='left') ax.text(0.999, 0.999, 'top-right', transform=ax.transAxes, va='top', ha='right') ax.text(0.999, 0.001, 'bottom-right', transform=ax.transAxes, va='baseline', ha='right') renderer = run_fig(fig) for data_no, data_dict in enumerate(renderer.plotly_fig['data']): equivalent, msg = compare_dict(data_dict, ANNOTATIONS['data'][data_no]) assert equivalent, msg for no, note in enumerate(renderer.plotly_fig['layout']['annotations']): equivalent, msg = compare_dict(note, ANNOTATIONS['layout']['annotations'][no]) assert equivalent, msg <|fim▁end|>
test_annotations
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils <|fim▁hole|> LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value<|fim▁end|>
from hotzenplotz.common import exception from hotzenplotz.api import validator
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): <|fim_middle|> <|fim▁end|>
"""Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): <|fim_middle|> # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): <|fim_middle|> def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e))
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): <|fim_middle|> def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully")
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): <|fim_middle|> def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully")
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): <|fim_middle|> def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully")
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): <|fim_middle|> def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
validate.check_tcp_request(request)
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], <|fim_middle|> def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
return "%s" % msg['uuid']
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): <|fim_middle|> def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): <|fim_middle|> def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): <|fim_middle|> <|fim▁end|>
value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': <|fim_middle|> elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e))
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': <|fim_middle|> elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e))
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': <|fim_middle|> def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e))
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: <|fim_middle|> cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
self.dir_path = '/etc/puppet/modules/cron/'
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): <|fim_middle|> except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
with open(file_path,'a') as f: f.write(output)
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: <|fim_middle|> LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e))
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: <|fim_middle|> rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
raise exception.HaproxyDeleteError(explanation=backup_path)
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: <|fim_middle|> if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
raise exception.HaproxyDeleteError(explanation=strerror)
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: <|fim_middle|> LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e))
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): <|fim_middle|> elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
value.append(line)
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): <|fim_middle|> return line_total - 1, value <|fim▁end|>
return i, value
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def <|fim_middle|>(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
__init__
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def <|fim_middle|>(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
do_config
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def <|fim_middle|>(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
_create_cron
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def <|fim_middle|>(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
_delete_cron
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def <|fim_middle|>(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
_update_cron
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def <|fim_middle|>(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
_validate_request
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def <|fim_middle|>(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
_get_lb_name
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def <|fim_middle|>(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
_is_lb_in_use
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def <|fim_middle|>(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def _get_one_lb_info(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
_test_syntax
<|file_name|>cron.py<|end_file_name|><|fim▁begin|>import os import datetime from jinja2 import Environment,PackageLoader,TemplateNotFound from hotzenplotz.openstack.common import cfg from hotzenplotz.openstack.common import log as logging from hotzenplotz.openstack.common import utils from hotzenplotz.common import exception from hotzenplotz.api import validator LOG = logging.getLogger(__name__) class CronHandler(object): """Handler Cron Resource """ def __init__(self, **kwargs): env = Environment(loader=PackageLoader('hotzenplotz.worker','templates')) self.template = env.get_template('cron') self.dir_path = None # @utils.synchronized('haproxy') def do_config(self, request): try: self._validate_request(request) except exception.BadRequest as e: LOG.warn('Bad request: %s' % e) raise exception.CronConfigureError(explanation=str(e)) cmd = request['method'] msg = request['cron_resource'] if cmd == 'create_cron': try: self._create_cron(msg) except exception.CronCreateError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'delete_cron': try: self._delete_cron(msg) except exception.HaproxyDeleteError as e: raise exception.CronConfigureError(explanation=str(e)) elif cmd == 'update_cron': try: self._update_cron(msg) except exception.CronUpdateError as e: raise exception.CronConfigureError(explanation=str(e)) def _create_cron(self,msg,syntax_check=False): try: output = self.template.render(cron_resource=msg) except TemplateNotFound as e: raise TemplateNotFound(str(e)) try: if not self.dir_path: self.dir_path = '/etc/puppet/modules/cron/' cron_name = msg['title'] file_path = self.dir_path + cron_name if not path.exists(file_path): with open(file_path,'a') as f: f.write(output) except exception.CronCreateError as e: raise exception.CronCreateError(explanation=str(e)) if syntax_check: try: self._test_syntax(file_path) except exception.ProcessExecutionError as e: raise exception.CronCreateError(explanation=str(e)) LOG.debug("Created the new cron successfully") def _delete_cron(self, msg): LOG.debug("Deleting cron for NAME:%s USER: %s PROJECT:%s" % (msg['id'], msg['user_id'], msg['project_id'])) try: new_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) return ##raise exception.HaproxyDeleteError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyDeleteError(explanation=str(e)) rc, backup_path = self._backup_original_cfg() if rc != 0: raise exception.HaproxyDeleteError(explanation=backup_path) rc, strerror = self._replace_original_cfg_with_new(new_cfg_path) if rc != 0: raise exception.HaproxyDeleteError(explanation=strerror) if self._reload_haproxy_cfg(backup_path) != 0: e = 'Failed to reload haproxy' raise exception.HaproxyDeleteError(explanation=str(e)) LOG.debug("Deleted the new load balancer successfully") def _update_cron(self, msg): LOG.debug("Updating the haproxy load " "balancer for NAME:%s USER: %s PROJECT:%s" % (msg['uuid'], msg['user_id'], msg['project_id'])) try: lb_deleted_cfg_path = self._create_lb_deleted_haproxy_cfg(msg) except exception.HaproxyLBNotExists as e: LOG.warn('%s', e) raise exception.HaproxyUpdateError(explanation=str(e)) try: new_cfg_path = self._create_lb_haproxy_cfg( msg, base_cfg_path=lb_deleted_cfg_path) except exception.HaproxyCreateCfgError as e: raise exception.HaproxyUpdateError(explanation=str(e)) try: self._test_haproxy_config(new_cfg_path) except exception.ProcessExecutionError as e: raise exception.HaproxyUpdateError(explanation=str(e)) LOG.debug("Updated the new load balancer successfully") def _validate_request(self, request): validate.check_tcp_request(request) def _get_lb_name(self, msg): # TODO(wenjianhn): utf-8 support, base64 ##return "%s_%s" % (msg['project_id'], return "%s" % msg['uuid'] def _is_lb_in_use(self, lb_name, base_cfg_path='/etc/haproxy/haproxy.cfg'): with open(base_cfg_path) as cfg: lines = cfg.readlines() try: in_use_lb_name = [line.split()[1] for line in lines if line.startswith('listen')] except IndexError: LOG.error("No item was found after listen directive," "is the haproxy configuraion file valid?") raise return lb_name in in_use_lb_name def _test_syntax(self, cfile_path): LOG.info('Testing the new puppet configuration file') cmd = "puppet parser validate %s" % cfile_path try: utils.execute(cmd) except exception.ProcessExecutionError as e: LOG.warn('Did not pass the configuration syntax test: %s', e) raise def <|fim_middle|>(self, line_all, line_index, line_total): value = [] for i in range(line_index, line_total): line = line_all[i] if line.startswith('\t'): value.append(line) elif line.startswith('listen'): return i, value return line_total - 1, value <|fim▁end|>
_get_one_lb_info
<|file_name|>power_digit_sum.py<|end_file_name|><|fim▁begin|><|fim▁hole|> return sum([int(x) for x in power_of_2])<|fim▁end|>
def power_digit_sum(exponent): power_of_2 = str(2 ** exponent)
<|file_name|>power_digit_sum.py<|end_file_name|><|fim▁begin|>def power_digit_sum(exponent): <|fim_middle|> <|fim▁end|>
power_of_2 = str(2 ** exponent) return sum([int(x) for x in power_of_2])
<|file_name|>power_digit_sum.py<|end_file_name|><|fim▁begin|>def <|fim_middle|>(exponent): power_of_2 = str(2 ** exponent) return sum([int(x) for x in power_of_2])<|fim▁end|>
power_digit_sum
<|file_name|>test_auto_segmentEG_FEMPO.py<|end_file_name|><|fim▁begin|>import pandas as pd from sklearn.datasets import load_boston from sklearn.linear_model import LinearRegression from sklearn.tree import DecisionTreeRegressor from sklearn.cross_validation import train_test_split from sklearn.metrics import mean_squared_error from .auto_segment_FEMPO import BasicSegmenter_FEMPO def demo(X = None, y = None, test_size = 0.1): if X == None: boston = load_boston() X = pd.DataFrame(boston.data) y = pd.DataFrame(boston.target) <|fim▁hole|> X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size) print X_train.shape # If you want to compare with BaggingRegressor. # bench = BaggingRegressor(base_estimator = base_estimator, n_estimators = 10, max_samples = 1, oob_score = True).fit(X_train, y_train) # print bench.score(X_test, y_test) # print mean_squared_error(bench.predict(X_test), y_test) clf = BasicSegmenterEG_FEMPO(ngen=30,init_sample_percentage = 1, n_votes=10, n = 10, base_estimator = base_estimator, unseen_x = X_test, unseen_y = y_test) clf.fit(X_train, y_train) print clf.score(X_test,y_test) y = clf.predict(X_test) print mean_squared_error(y, y_test) print y.shape return clf, X_test, y_test<|fim▁end|>
base_estimator = DecisionTreeRegressor(max_depth = 5)
<|file_name|>test_auto_segmentEG_FEMPO.py<|end_file_name|><|fim▁begin|>import pandas as pd from sklearn.datasets import load_boston from sklearn.linear_model import LinearRegression from sklearn.tree import DecisionTreeRegressor from sklearn.cross_validation import train_test_split from sklearn.metrics import mean_squared_error from .auto_segment_FEMPO import BasicSegmenter_FEMPO def demo(X = None, y = None, test_size = 0.1): <|fim_middle|> <|fim▁end|>
if X == None: boston = load_boston() X = pd.DataFrame(boston.data) y = pd.DataFrame(boston.target) base_estimator = DecisionTreeRegressor(max_depth = 5) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size) print X_train.shape # If you want to compare with BaggingRegressor. # bench = BaggingRegressor(base_estimator = base_estimator, n_estimators = 10, max_samples = 1, oob_score = True).fit(X_train, y_train) # print bench.score(X_test, y_test) # print mean_squared_error(bench.predict(X_test), y_test) clf = BasicSegmenterEG_FEMPO(ngen=30,init_sample_percentage = 1, n_votes=10, n = 10, base_estimator = base_estimator, unseen_x = X_test, unseen_y = y_test) clf.fit(X_train, y_train) print clf.score(X_test,y_test) y = clf.predict(X_test) print mean_squared_error(y, y_test) print y.shape return clf, X_test, y_test
<|file_name|>test_auto_segmentEG_FEMPO.py<|end_file_name|><|fim▁begin|>import pandas as pd from sklearn.datasets import load_boston from sklearn.linear_model import LinearRegression from sklearn.tree import DecisionTreeRegressor from sklearn.cross_validation import train_test_split from sklearn.metrics import mean_squared_error from .auto_segment_FEMPO import BasicSegmenter_FEMPO def demo(X = None, y = None, test_size = 0.1): if X == None: <|fim_middle|> base_estimator = DecisionTreeRegressor(max_depth = 5) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size) print X_train.shape # If you want to compare with BaggingRegressor. # bench = BaggingRegressor(base_estimator = base_estimator, n_estimators = 10, max_samples = 1, oob_score = True).fit(X_train, y_train) # print bench.score(X_test, y_test) # print mean_squared_error(bench.predict(X_test), y_test) clf = BasicSegmenterEG_FEMPO(ngen=30,init_sample_percentage = 1, n_votes=10, n = 10, base_estimator = base_estimator, unseen_x = X_test, unseen_y = y_test) clf.fit(X_train, y_train) print clf.score(X_test,y_test) y = clf.predict(X_test) print mean_squared_error(y, y_test) print y.shape return clf, X_test, y_test <|fim▁end|>
boston = load_boston() X = pd.DataFrame(boston.data) y = pd.DataFrame(boston.target)
<|file_name|>test_auto_segmentEG_FEMPO.py<|end_file_name|><|fim▁begin|>import pandas as pd from sklearn.datasets import load_boston from sklearn.linear_model import LinearRegression from sklearn.tree import DecisionTreeRegressor from sklearn.cross_validation import train_test_split from sklearn.metrics import mean_squared_error from .auto_segment_FEMPO import BasicSegmenter_FEMPO def <|fim_middle|>(X = None, y = None, test_size = 0.1): if X == None: boston = load_boston() X = pd.DataFrame(boston.data) y = pd.DataFrame(boston.target) base_estimator = DecisionTreeRegressor(max_depth = 5) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size) print X_train.shape # If you want to compare with BaggingRegressor. # bench = BaggingRegressor(base_estimator = base_estimator, n_estimators = 10, max_samples = 1, oob_score = True).fit(X_train, y_train) # print bench.score(X_test, y_test) # print mean_squared_error(bench.predict(X_test), y_test) clf = BasicSegmenterEG_FEMPO(ngen=30,init_sample_percentage = 1, n_votes=10, n = 10, base_estimator = base_estimator, unseen_x = X_test, unseen_y = y_test) clf.fit(X_train, y_train) print clf.score(X_test,y_test) y = clf.predict(X_test) print mean_squared_error(y, y_test) print y.shape return clf, X_test, y_test <|fim▁end|>
demo
<|file_name|>test_reset_password.py<|end_file_name|><|fim▁begin|>from djangosanetesting.cases import HttpTestCase from django.conf import settings from django.core.urlresolvers import reverse from django.core import mail from accounts.tests import testdata class TestResetPassword(HttpTestCase): def __init__(self, *args, **kwargs): super(self.__class__, self).__init__(*args, **kwargs) self.host = 'localhost' self.port = 8000 def setUp(self): testdata.run() def test_reset_password(self): res = self.client.post(reverse('password_reset'), {'register_number' : settings.TEST_USERNAME, }, follow=True) assert reverse('password_reset_done') in res.request['PATH_INFO'] assert len(mail.outbox) == 1 reset_url = [word for word in mail.outbox[0].body.split() if word.startswith('http')][0] res = self.client.get(reset_url, follow=True)<|fim▁hole|> assert 'unsuccessful' not in res.content.lower() assert 'change my password' in res.content.lower() # I've to stop here, because next step is to change password at Google Apps. # Can't mess up production database.<|fim▁end|>
assert res.status_code == 200
<|file_name|>test_reset_password.py<|end_file_name|><|fim▁begin|>from djangosanetesting.cases import HttpTestCase from django.conf import settings from django.core.urlresolvers import reverse from django.core import mail from accounts.tests import testdata class TestResetPassword(HttpTestCase): <|fim_middle|> <|fim▁end|>
def __init__(self, *args, **kwargs): super(self.__class__, self).__init__(*args, **kwargs) self.host = 'localhost' self.port = 8000 def setUp(self): testdata.run() def test_reset_password(self): res = self.client.post(reverse('password_reset'), {'register_number' : settings.TEST_USERNAME, }, follow=True) assert reverse('password_reset_done') in res.request['PATH_INFO'] assert len(mail.outbox) == 1 reset_url = [word for word in mail.outbox[0].body.split() if word.startswith('http')][0] res = self.client.get(reset_url, follow=True) assert res.status_code == 200 assert 'unsuccessful' not in res.content.lower() assert 'change my password' in res.content.lower() # I've to stop here, because next step is to change password at Google Apps. # Can't mess up production database.
<|file_name|>test_reset_password.py<|end_file_name|><|fim▁begin|>from djangosanetesting.cases import HttpTestCase from django.conf import settings from django.core.urlresolvers import reverse from django.core import mail from accounts.tests import testdata class TestResetPassword(HttpTestCase): def __init__(self, *args, **kwargs): <|fim_middle|> def setUp(self): testdata.run() def test_reset_password(self): res = self.client.post(reverse('password_reset'), {'register_number' : settings.TEST_USERNAME, }, follow=True) assert reverse('password_reset_done') in res.request['PATH_INFO'] assert len(mail.outbox) == 1 reset_url = [word for word in mail.outbox[0].body.split() if word.startswith('http')][0] res = self.client.get(reset_url, follow=True) assert res.status_code == 200 assert 'unsuccessful' not in res.content.lower() assert 'change my password' in res.content.lower() # I've to stop here, because next step is to change password at Google Apps. # Can't mess up production database. <|fim▁end|>
super(self.__class__, self).__init__(*args, **kwargs) self.host = 'localhost' self.port = 8000
<|file_name|>test_reset_password.py<|end_file_name|><|fim▁begin|>from djangosanetesting.cases import HttpTestCase from django.conf import settings from django.core.urlresolvers import reverse from django.core import mail from accounts.tests import testdata class TestResetPassword(HttpTestCase): def __init__(self, *args, **kwargs): super(self.__class__, self).__init__(*args, **kwargs) self.host = 'localhost' self.port = 8000 def setUp(self): <|fim_middle|> def test_reset_password(self): res = self.client.post(reverse('password_reset'), {'register_number' : settings.TEST_USERNAME, }, follow=True) assert reverse('password_reset_done') in res.request['PATH_INFO'] assert len(mail.outbox) == 1 reset_url = [word for word in mail.outbox[0].body.split() if word.startswith('http')][0] res = self.client.get(reset_url, follow=True) assert res.status_code == 200 assert 'unsuccessful' not in res.content.lower() assert 'change my password' in res.content.lower() # I've to stop here, because next step is to change password at Google Apps. # Can't mess up production database. <|fim▁end|>
testdata.run()
<|file_name|>test_reset_password.py<|end_file_name|><|fim▁begin|>from djangosanetesting.cases import HttpTestCase from django.conf import settings from django.core.urlresolvers import reverse from django.core import mail from accounts.tests import testdata class TestResetPassword(HttpTestCase): def __init__(self, *args, **kwargs): super(self.__class__, self).__init__(*args, **kwargs) self.host = 'localhost' self.port = 8000 def setUp(self): testdata.run() def test_reset_password(self): <|fim_middle|> <|fim▁end|>
res = self.client.post(reverse('password_reset'), {'register_number' : settings.TEST_USERNAME, }, follow=True) assert reverse('password_reset_done') in res.request['PATH_INFO'] assert len(mail.outbox) == 1 reset_url = [word for word in mail.outbox[0].body.split() if word.startswith('http')][0] res = self.client.get(reset_url, follow=True) assert res.status_code == 200 assert 'unsuccessful' not in res.content.lower() assert 'change my password' in res.content.lower() # I've to stop here, because next step is to change password at Google Apps. # Can't mess up production database.
<|file_name|>test_reset_password.py<|end_file_name|><|fim▁begin|>from djangosanetesting.cases import HttpTestCase from django.conf import settings from django.core.urlresolvers import reverse from django.core import mail from accounts.tests import testdata class TestResetPassword(HttpTestCase): def <|fim_middle|>(self, *args, **kwargs): super(self.__class__, self).__init__(*args, **kwargs) self.host = 'localhost' self.port = 8000 def setUp(self): testdata.run() def test_reset_password(self): res = self.client.post(reverse('password_reset'), {'register_number' : settings.TEST_USERNAME, }, follow=True) assert reverse('password_reset_done') in res.request['PATH_INFO'] assert len(mail.outbox) == 1 reset_url = [word for word in mail.outbox[0].body.split() if word.startswith('http')][0] res = self.client.get(reset_url, follow=True) assert res.status_code == 200 assert 'unsuccessful' not in res.content.lower() assert 'change my password' in res.content.lower() # I've to stop here, because next step is to change password at Google Apps. # Can't mess up production database. <|fim▁end|>
__init__
<|file_name|>test_reset_password.py<|end_file_name|><|fim▁begin|>from djangosanetesting.cases import HttpTestCase from django.conf import settings from django.core.urlresolvers import reverse from django.core import mail from accounts.tests import testdata class TestResetPassword(HttpTestCase): def __init__(self, *args, **kwargs): super(self.__class__, self).__init__(*args, **kwargs) self.host = 'localhost' self.port = 8000 def <|fim_middle|>(self): testdata.run() def test_reset_password(self): res = self.client.post(reverse('password_reset'), {'register_number' : settings.TEST_USERNAME, }, follow=True) assert reverse('password_reset_done') in res.request['PATH_INFO'] assert len(mail.outbox) == 1 reset_url = [word for word in mail.outbox[0].body.split() if word.startswith('http')][0] res = self.client.get(reset_url, follow=True) assert res.status_code == 200 assert 'unsuccessful' not in res.content.lower() assert 'change my password' in res.content.lower() # I've to stop here, because next step is to change password at Google Apps. # Can't mess up production database. <|fim▁end|>
setUp
<|file_name|>test_reset_password.py<|end_file_name|><|fim▁begin|>from djangosanetesting.cases import HttpTestCase from django.conf import settings from django.core.urlresolvers import reverse from django.core import mail from accounts.tests import testdata class TestResetPassword(HttpTestCase): def __init__(self, *args, **kwargs): super(self.__class__, self).__init__(*args, **kwargs) self.host = 'localhost' self.port = 8000 def setUp(self): testdata.run() def <|fim_middle|>(self): res = self.client.post(reverse('password_reset'), {'register_number' : settings.TEST_USERNAME, }, follow=True) assert reverse('password_reset_done') in res.request['PATH_INFO'] assert len(mail.outbox) == 1 reset_url = [word for word in mail.outbox[0].body.split() if word.startswith('http')][0] res = self.client.get(reset_url, follow=True) assert res.status_code == 200 assert 'unsuccessful' not in res.content.lower() assert 'change my password' in res.content.lower() # I've to stop here, because next step is to change password at Google Apps. # Can't mess up production database. <|fim▁end|>
test_reset_password
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size <|fim▁hole|> def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options)<|fim▁end|>
@cached_property
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): <|fim_middle|> class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): <|fim_middle|> @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): <|fim_middle|> @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
self._get_properties(['width']) return self.width
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): <|fim_middle|> class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
self._get_properties(['height']) return self.height
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): <|fim_middle|> class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent)
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? <|fim_middle|> def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient)
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): <|fim_middle|> def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target)
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): <|fim_middle|> def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target)
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): <|fim_middle|> class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent)
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): <|fim_middle|> <|fim▁end|>
event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options)
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? <|fim_middle|> <|fim▁end|>
options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options)
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: <|fim_middle|> @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
image = Image.open(self.path) self.width, self.height = image.size
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: <|fim_middle|> else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: <|fim_middle|> if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg'
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': <|fim_middle|> if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
image_crop.format = 'jpeg' ext = '.jpeg'
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: <|fim_middle|> if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor)
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: <|fim_middle|> if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
image_crop = image_crop.filter(self.prop.filter)
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set <|fim_middle|> if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
ext = '.' + image.format.lower()
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: <|fim_middle|> image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name)
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: <|fim_middle|> image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
kw = dict(kw, optimize=True)
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. <|fim_middle|> def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient)
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky <|fim_middle|> class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent)
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: <|fim_middle|> class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent)
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: <|fim_middle|> if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
return
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): <|fim_middle|> ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def <|fim_middle|>(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
_get_properties
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def <|fim_middle|>(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
width
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def <|fim_middle|>(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
height
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def <|fim_middle|>(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
_2persistent
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def <|fim_middle|>(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
before_update
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def <|fim_middle|>(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
before_insert
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def <|fim_middle|>(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def _set_options(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
_fill_img
<|file_name|>images.py<|end_file_name|><|fim▁begin|>import os, logging from PIL import Image from sqlalchemy.orm.session import object_session from sqlalchemy.orm.util import identity_key from iktomi.unstable.utils.image_resizers import ResizeFit from iktomi.utils import cached_property from ..files import TransientFile, PersistentFile from .files import FileEventHandlers, FileProperty logger = logging.getLogger(__name__) class ImageFile(PersistentFile): def _get_properties(self, properties=['width', 'height']): if 'width' in properties or 'height' in properties: image = Image.open(self.path) self.width, self.height = image.size @cached_property def width(self): self._get_properties(['width']) return self.width @cached_property def height(self): self._get_properties(['height']) return self.height class ImageEventHandlers(FileEventHandlers): def _2persistent(self, target, transient): # XXX move this method to file_manager # XXX Do this check or not? image = Image.open(transient.path) assert image.format in Image.SAVE and image.format != 'bmp',\ 'Unsupported image format' if self.prop.image_sizes: session = object_session(target) persistent_name = getattr(target, self.prop.attribute_name) pn, ext = os.path.splitext(persistent_name) image_crop = self.prop.resize(image, self.prop.image_sizes) if self.prop.force_rgb and image_crop.mode not in ['RGB', 'RGBA']: image_crop = image_crop.convert('RGB') if ext == '.gif': image_crop.format = 'jpeg' ext = '.jpeg' if self.prop.enhancements: for enhance, factor in self.prop.enhancements: image_crop = enhance(image_crop).enhance(factor) if self.prop.filter: image_crop = image_crop.filter(self.prop.filter) if not ext: # set extension if it is not set ext = '.' + image.format.lower() if pn + ext != persistent_name: persistent_name = pn + ext # XXX hack? setattr(target, self.prop.attribute_name, persistent_name) image_attr = getattr(target.__class__, self.prop.key) file_manager = persistent = session.find_file_manager(image_attr) persistent = file_manager.get_persistent(persistent_name, self.prop.persistent_cls) transient = session.find_file_manager(image_attr).new_transient(ext) kw = dict(quality=self.prop.quality) if self.prop.optimize: kw = dict(kw, optimize=True) image_crop.save(transient.path, **kw) session.find_file_manager(image_attr).store(transient, persistent) return persistent else: # Attention! This method can accept PersistentFile. # In this case one shold NEVER been deleted or rewritten. assert isinstance(transient, TransientFile), repr(transient) return FileEventHandlers._2persistent(self, target, transient) def before_update(self, mapper, connection, target): FileEventHandlers.before_update(self, mapper, connection, target) self._fill_img(mapper, connection, target) def before_insert(self, mapper, connection, target): FileEventHandlers.before_insert(self, mapper, connection, target) self._fill_img(mapper, connection, target) def _fill_img(self, mapper, connection, target): if self.prop.fill_from: # XXX Looks hacky value = getattr(target, self.prop.key) if value is None: base = getattr(target, self.prop.fill_from) if base is None: return if not os.path.isfile(base.path): logger.warn('Original file is absent %s %s %s', identity_key(instance=target), self.prop.fill_from, base.path) return ext = os.path.splitext(base.name)[1] session = object_session(target) image_attr = getattr(target.__class__, self.prop.key) name = session.find_file_manager(image_attr).new_file_name( self.prop.name_template, target, ext, '') setattr(target, self.prop.attribute_name, name) persistent = self._2persistent(target, base) setattr(target, self.prop.key, persistent) class ImageProperty(FileProperty): event_cls = ImageEventHandlers def <|fim_middle|>(self, options): # XXX rename image_sizes? options = dict(options) self.image_sizes = options.pop('image_sizes', None) self.resize = options.pop('resize', None) or ResizeFit() # XXX implement self.fill_from = options.pop('fill_from', None) self.filter = options.pop('filter', None) self.enhancements = options.pop('enhancements', []) self.force_rgb = self.enhancements or \ self.filter or \ options.pop('force_rgb', True) self.quality = options.pop('quality', 85) self.optimize = options.pop('optimize', False) assert self.fill_from is None or self.image_sizes is not None options.setdefault('persistent_cls', ImageFile) FileProperty._set_options(self, options) <|fim▁end|>
_set_options
<|file_name|>web_page_block.py<|end_file_name|><|fim▁begin|># -*- coding: utf-8 -*- # Copyright (c) 2020, Frappe Technologies and contributors # For license information, please see license.txt from __future__ import unicode_literals # import frappe from frappe.model.document import Document<|fim▁hole|><|fim▁end|>
class WebPageBlock(Document): pass
<|file_name|>web_page_block.py<|end_file_name|><|fim▁begin|># -*- coding: utf-8 -*- # Copyright (c) 2020, Frappe Technologies and contributors # For license information, please see license.txt from __future__ import unicode_literals # import frappe from frappe.model.document import Document class WebPageBlock(Document): <|fim_middle|> <|fim▁end|>
pass
<|file_name|>test.py<|end_file_name|><|fim▁begin|>from planarprocess import * from gds_helpers import * from itertools import cycle xmin, xmax = -5, 5 layers = gds_cross_section('mypmos.gds', [(0,xmin), (0, xmax)], 'gdsmap.map')<|fim▁hole|>['P-Active-Well', 'Active-Cut', 'N-Well', 'Metal-2', 'Metal-1', 'P-Select', 'N-Select', 'Transistor-Poly', 'Via1'] wafer = Wafer(1., 5., 0, xmax - xmin) # N-Well nw = layers['N-Well'] wafer.implant(.7, nw, outdiffusion=5., label='N-Well') # Field and gate oxides de = layers['P-Active-Well'] # TODO: channel stop under field oxide fox = wafer.grow(.5, wafer.blank_mask().difference(de), y_offset=-.2, outdiffusion=.1) gox = wafer.grow(.05, de, outdiffusion=.05, base=wafer.wells, label='Gate oxide') # Gate poly and N+/P+ implants gp = layers['Transistor-Poly'] poly = wafer.grow(.25, gp, outdiffusion=.25, label='Gate poly') np = layers['N-Select'].intersection( layers['P-Active-Well']).difference(gp) nplus = wafer.implant(.1, np, outdiffusion=.1, target=wafer.wells, source=gox, label='N+') pp = layers['P-Select'].intersection( layers['P-Active-Well']).difference(gp) pplus = wafer.implant(.1, pp, outdiffusion=.1, target=wafer.wells, source=gox, label='P+') # Multi-level dielectric and contacts mld_thickness = .5 mld = wafer.grow(mld_thickness, wafer.blank_mask(), outdiffusion=.1) ct = layers['Active-Cut'] contact = wafer.grow(-mld_thickness*1.1, ct, consuming=[mld, gox], base=wafer.air, outdiffusion=.05, outdiffusion_vertices=3) # Metals and vias m1 = layers['Metal-1'] metal1 = wafer.grow(.6, m1, outdiffusion=.1, label='Metal-1') ild_thickness = 1.2 ild1 = wafer.grow(ild_thickness, wafer.blank_mask(), outdiffusion=.1) wafer.planarize() v1 = layers['Via1'] via1 = wafer.grow(-ild_thickness*1.1, v1, consuming=[ild1], base=wafer.air, outdiffusion=.05, outdiffusion_vertices=3) m2 = layers['Metal-2'] metal2 = wafer.grow(1., m2, outdiffusion=.1, label='Metal-2') # Presentation custom_style = {s: {} for s in wafer.solids} for solid, color in { fox: '.4', gox: 'r', poly: 'g', mld: 'k', ild1: '.3', contact: '.5', via1: '.5', metal1: '.7', metal2: '.8'}.items(): custom_style[solid].update(dict(facecolor=color, edgecolor='k')) for solid in wafer.solids: if solid not in wafer.wells: custom_style[solid].update(dict(hatch=None, fill=True)) base_hatches = r'\/' # r'/\|-+xoO.*' hatches = cycle(list(base_hatches) + [h1+h2 for h1 in base_hatches for h2 in base_hatches]) colors = cycle('krgbcmy') plot_geometryref(wafer.air, hatch='.', fill=False, linewidth=0, color=(.9,.9,.9), zorder=-100) zorder = -99 for solid in wafer.solids: style = dict(hatch=next(hatches), fill=False, edgecolor=next(colors), zorder=zorder) zorder += 1 style.update(custom_style.get(solid, {})) plot_geometryref(solid, **style) pyplot.legend() pyplot.savefig('mypmos-x.png') pyplot.show()<|fim▁end|>