Пример #1
0
    def synchronize(self, *args, **options):
        if REMOTE is None:
            # Because of BaseCommand bug (#18387, fixed in Django 1.5), we cannot use CommandError
            # in tests. Hence this hook.
            exception_class = options.get("exception_class", CommandError)
            raise exception_class("No REMOTE database specified in settings.")

        since = app_options.last_check
        last_time = datetime.now()
        logs = ChangeLog.objects.filter(date__gt=since).select_related().order_by("date", "pk")

        # Don't synchronize if object should be added/changed and later deleted;
        to_del = {}
        for log in logs:
            if log.action == DELETION:
                to_del[(log.content_type, log.object_id)] = log.date

        for log in logs:
            last_time = log.date
            del_time = to_del.get((log.content_type, log.object_id))
            if last_time == del_time and log.action == DELETION:
                ACTIONS[log.action](log.content_type, log.object_id, log)
                # delete record so that next actions with the same time can be performed
                del to_del[(log.content_type, log.object_id)]
            if del_time is None or last_time > del_time:
                ACTIONS[log.action](log.content_type, log.object_id, log)

        if len(logs):
            app_options.last_check = last_time
            return _t("Synchronization performed successfully.")
        else:
            return _t("No changes since last synchronization.")
Пример #2
0
  def clean(self):
    self.qtable_list = None
    if filter(None, [ not f.is_valid() for f in self.forms ]):
      return

    qt_by_name = { }                    # Dictionary of name -> [ QTable list ]
    n_display = 0
    for form in self.forms:
      if form.cleaned_data['display']:
        n_display += 1

      # Gather a list of QTables (qtable_list) involved, and check for naming collision
      if form.cleaned_data['source'] != 'table':
        continue

      curr = form.qtable
      qt_list = qt_by_name.get(curr.name, [ ])
      for qt in qt_list:
        # Error if a table has alias but another doesn't. (Tables with the same name.)
        if bool(curr.alias) ^ bool(qt.alias):
          raise forms.ValidationError(_t('Ambiguous table "%(table)s" without alias') % {'table': qt.name})
        if curr.alias == qt.alias:
          # Duplicate. Don't update.
          break
      else:
        qt_list.append(curr)
        qt_by_name[curr.name] = qt_list

    self.qtable_list = sum([ tbl_list for tbl_list in qt_by_name.values() ], [ ])
    if not self.qtable_list:
      raise forms.ValidationError(_t('Not selecting from any table column'))
    if n_display == 0:
      raise forms.ValidationError(_t('Not displaying any selection'))
Пример #3
0
 def add_arguments(self, parser):
     parser.add_argument("--dn", help=_t("Whether or not the user should be imported by "
                              "distinguished name."),
                         action="store_true",
                         default=False)
     parser.add_argument("--sync-groups", help=_t("Sync groups of the users."),
                                  action="store_true",
                                  default=False)
     parser.add_argument("--server", help=_t("Server to connect to."),
                             action="store",
                             default=None)
Пример #4
0
 def old(self):
   if delimiter.isdigit():
     try:
       chr(int(delimiter))
       return int(delimiter)
     except ValueError:
       raise forms.ValidationError(_t('Delimiter value must be smaller than 256.'))
   val = delimiter.decode('string_escape')
   if len(val) != 1:
     raise forms.ValidationError(_t('Delimiter must be exactly one character.'))
   return ord(val)
Пример #5
0
 def _display_check(self):
   """Reconcile 'display' with 'source'"""
   src = self.cleaned_data.get('source')
   if not self.cleaned_data.get('display'):
     if src and src != 'table':
       raise forms.ValidationError(_t('Source must be "table" when not displaying column'))
     self.cleaned_data['source'] = 'table'
     if self.cleaned_data.get('col_alias'):
       raise forms.ValidationError(_t('Column alias not applicable when not displaying column'))
   else:
     if not src:
       raise forms.ValidationError(_t('Source value missing'))
Пример #6
0
  def clean(self):
    if self.errors:
      return

    # Verify unary operators constraints
    check_right = True
    op = self.cleaned_data['op']
    if op in common.RELATION_OPS_UNARY:
      if self.cleaned_data.get('r_source') or self.cleaned_data.get('r_cond'):
        raise forms.ValidationError(_t('Operator %(operator)s does not take the right operand') % {'operator': op})
      check_right = False
    else:
      if not self.cleaned_data.get('l_source') or not self.cleaned_data.get('r_source'):
        raise forms.ValidationError(_t('Operator %(operator)s takes both operands') % {'operator': op})

    # Verify the lhs values match the source
    l_source = self.cleaned_data['l_source']
    l_constant = self.cleaned_data.get('l_constant')
    _field_source_check(l_source, _t('Constant (Left)'), l_constant, is_from_table=False)
    l_table = self.cleaned_data.get('l_table')
    _field_source_check(l_source, _t('Table (Left)'), l_table, is_from_table=True)
    l_col = self.cleaned_data.get('l_col')
    _field_source_check(l_source, _t('Column (Left)'), l_col, is_from_table=True)

    if check_right:
      # Verify the rhs values match the source
      r_source = self.cleaned_data['r_source']
      r_constant = self.cleaned_data.get('r_constant')
      _field_source_check(r_source, _t('Constant (Right)'), r_constant, is_from_table=False)
      r_table = self.cleaned_data.get('r_table')
      _field_source_check(r_source, _t('Table (Right)'), r_table, is_from_table=True)
      r_col = self.cleaned_data.get('r_col')
      _field_source_check(r_source, _t('Column (Right)'), r_col, is_from_table=True)
    return self.cleaned_data
Пример #7
0
def _field_source_check(true_source, field_name, field_value, is_from_table):
  """
  Some fields come from a table (is_from_table). And they should be specified iff
  the true_source (what the user selected) says "table". The same holds for constant
  source. This function verifies that constraint and would raise ValidationError.

  Returns whether this field is required.
  """
  if bool(true_source == 'table') ^ bool(is_from_table):
    if field_value:
      raise forms.ValidationError(_t('%(field)s value not applicable with %(source)s source') %
                                  {'field': field_name, 'source': true_source})
    return False
  elif not field_value:
    raise forms.ValidationError(_t('%(field)s value missing') % {'field': field_name})
  return True
Пример #8
0
 def clean(self):
   # ChoiceOrOtherField doesn't work with required=True
   delimiter = self.cleaned_data.get('delimiter')
   if not delimiter:
     raise forms.ValidationError(_t('Delimiter value is required.'))
   _clean_terminator(delimiter)
   return self.cleaned_data
Пример #9
0
def _extract_condition(union_mform, table_alias_dict):
  """
  Extract LogicalUnion's from each form in union_mform, and recurse into the child union.
  Returns a LogicalUnion.
  """
  global SUB_UNION_PREFIX
  if not union_mform.is_valid():
    assert False, _t('UnionMultiForm is not valid')
    return None

  op = union_mform.bool.cleaned_data['bool']
  res = report_gen.LogicalUnion(op)
  for cond_form in union_mform.conds.forms:
    res.add_cond(cond_form.get_boolean_condition(table_alias_dict))

  n_children = union_mform.mgmt.form_counts()
  for i in range(0, n_children):
    child_name = '%s%d' % (SUB_UNION_PREFIX, i)
    try:
      sub_form = getattr(union_mform, child_name)
      res.add_subunion(_extract_condition(sub_form, table_alias_dict))
    except AttributeError:
      LOG.debug('Subform not found: %s %s' % (union_mform, child_name))
      continue

  return res
Пример #10
0
 def add_arguments(self, parser):
   parser.add_argument("--dn", help=_t("Whether or not the user should be imported by "
                              "distinguished name."),
                         action="store_true",
                         default=False)
   parser.add_argument("--import-members", help=_t("Import users from the group."),
                                     action="store_true",
                                     default=False)
   parser.add_argument("--import-members-recursive", help=_t("Import users from the group, but also do so recursively."),
                                               action="store_true",
                                               default=False)
   parser.add_argument("--sync-users", help=_t("Sync users in the group."),
                                 action="store_true",
                                 default=False)
   parser.add_argument("--server", help=_t("Server to connect to."),
                             action="store",
                             default=None)
Пример #11
0
def config_validator(user):
  res = []

  yarn_cluster = cluster.get_cluster_conf_for_job_submission()

  if yarn_cluster.SECURITY_ENABLED.get() and not os.path.exists(SQOOP_CONF_DIR.get()):
    res.append((NICE_NAME, _t("The app won't work without a valid %s property.") % SQOOP_CONF_DIR.grab_key))

  return res
Пример #12
0
 def clean(self):
   if self.errors:
     return
   save = self.cleaned_data.get('save')
   name = self.cleaned_data.get('name')
   if save and len(name) == 0:
     # Bother with name iff we're saving
     raise forms.ValidationError(_t('Please enter a name'))
   return self.cleaned_data
Пример #13
0
 def clean_target_table(self):
   tbl = self.cleaned_data.get('target_table')
   if tbl:
     try:
       db_utils.meta_client().get_table("default", tbl)
       raise forms.ValidationError(_t('Table already exists'))
     except hive_metastore.ttypes.NoSuchObjectException:
       pass
   return tbl
Пример #14
0
Файл: models.py Проект: QLGu/hue
  def check_hue_permission(self, perm=None, app=None, action=None):
    """
    Raises a PopupException if permission is denied.

    Either perm or both app and action are required.
    """
    if perm is None:
      perm = self._lookup_permission(app, action)
    if self.has_hue_permission(perm):
      return
    else:
      raise PopupException(_t("You do not have permissions to %(description)s.") % dict(description=perm.description))
Пример #15
0
def fixup_union(parent_mform, subform_name, data, is_root=False):
  """
  Create child union mforms dynamically. Note that the parent_mform may be invalid.
  The parent_mform is a MultiForm, in which the subform_name is a UnionMultiForm we
  need to fix.

  This method performs this dynamic construction of the child UnionMultiForm.
  Note that it applies to existing child forms (i.e. the child form exists and the
  user is submitting the query), as well as a newly added child (i.e. the user just
  clicked 'ADD' to add a sub-condition).

  We figure out the number of children from the mgmt form. Note that this is actually
  a count of the number of children we have ever had. It is a max of the number of
  children, some of which may have been deleted.

  For each child <i>, our strategy is to test if 'sub<i>' exists in the POST data.
  If so, we create a sub-UnionMultiForm for that child. And we do it recursively.
  """
  global SUB_UNION_PREFIX

  union_mform = getattr(parent_mform, subform_name)
  mgmt_form = union_mform.mgmt
  if not mgmt_form.is_valid():
    raise forms.ValidationError(_t('Missing ManagementForm for conditions'))
  n_children = mgmt_form.form_counts()

  # This removes our current subform (union_mform) and any children.
  if mgmt_form.cleaned_data['remove']:
    parent_mform.remove_subform(subform_name)
    LOG.debug('Removed subform: %s' % (union_mform,))
    # If we just removed the root union, add back an empty one.
    if is_root:
      parent_mform.add_subform('union', UnionMultiForm, data=None)
      LOG.debug('Adding root union back')
    return

  # Note that some of the n_children could be non-existent (i.e. deleted)
  for i in range(0, n_children):
    child_name = '%s%d' % (SUB_UNION_PREFIX, i)
    if not union_mform.has_subform_data(child_name, data):
      LOG.debug('Skipping over non-existent subform: %s %s' % (union_mform, child_name))
      continue
    union_mform.add_subform(child_name, UnionMultiForm, data)
    LOG.debug('Instantiating subform: %s %s' % (union_mform, child_name))
    # The child may have grand-children
    fixup_union(union_mform, child_name, data)

  if mgmt_form.cleaned_data['add']:
    id = mgmt_form.new_form_id()
    child_name = '%s%d' % (SUB_UNION_PREFIX, id)
    union_mform.add_subform(child_name, UnionMultiForm)
    LOG.debug('Added subform: %s %s' % (union_mform, child_name))
Пример #16
0
 def __init__(self, table_obj, *args, **kwargs):
   """
   @param table_obj is a hive_metastore.thrift Table object,
   used to add fields corresponding to partition keys.
   """
   super(LoadDataForm, self).__init__(*args, **kwargs)
   self.partition_columns = dict()
   for i, column in enumerate(table_obj.partition_keys):
     # We give these numeric names because column names
     # may be unpleasantly arbitrary.
     name = "partition_%d" % i
     char_field = forms.CharField(required=True, label=_t("%(column_name)s (partition key with type %(column_type)s)") % {'column_name': column.name, 'column_type': column.type})
     self.fields[name] = char_field
     self.partition_columns[name] = column.name
Пример #17
0
  def _make_selection(self, table_alias_dict, is_left):
    if is_left:
      prefix = 'l_'
    else:
      prefix = 'r_'

    source = self.cleaned_data[prefix + 'source']
    if source == 'table':
      table = self.cleaned_data[prefix + 'table']
      col = self.cleaned_data[prefix + 'col']
      try:
        return report_gen.ColumnSelection(table_alias_dict[table], col)
      except KeyError:
        raise forms.ValidationError(_t('Unknown table "%(table)s" in condition') % {'table': table})

    constant = self.cleaned_data[prefix + 'constant']
    return report_gen.ConstSelection(constant)
Пример #18
0
  def clean(self):
    self.qtable = None
    self.selection = None

    self._display_check()

    if self.cleaned_data.get('sort') and not self.cleaned_data['sort_hql']:
      raise KeyError()

    # Verify that the 'source' field is consistent with the other fields
    source = self.cleaned_data.get('source')
    if not source:
      return None                       # No point since we can't get source

    constant_val = self.cleaned_data.get('constant')
    _field_source_check(source, _t('Constant'), constant_val, is_from_table=False)

    table_val = self.cleaned_data.get('table')
    _field_source_check(source, _t('From table'), table_val, is_from_table=True)

    col_val = self.cleaned_data.get('col')
    _field_source_check(source, _t('From column'), col_val, is_from_table=True)

    if self.cleaned_data.get('sort', '') and not self.cleaned_data.get('sort_order', ''):
      raise forms.ValidationError(_t('Sort order missing'))

    if table_val:
      # Column must belong to the table
      self.qtable = report_gen.QTable(table_val, self.cleaned_data.get('table_alias'))
      if col_val == '*':
        if self.cleaned_data.get('col_alias'):
          raise forms.ValidationError(_t('Alias not applicable for selecting "*"'))
      elif col_val not in self.qtable.get_columns():
        raise forms.ValidationError(_t('Invalid column name "%(column)s"') % {'column': col_val})
      # ColumnSelection object
      self.selection = report_gen.ColumnSelection(self.qtable,
                                                  col_val,
                                                  self.cleaned_data.get('col_alias'))
    else:
      # ConstSelection object
      self.selection = report_gen.ConstSelection(constant_val,
                                                 self.cleaned_data.get('col_alias'))
    self.selection.distinct = self.cleaned_data.get('distinct', False)
    self.selection.set_aggregation(self.cleaned_data.get('agg', ''))

    if self.errors:
      delattr(self, 'selection')
    return self.cleaned_data
Пример #19
0
        help_text=_t("Specify if column_type is char"))
    varchar_length = forms.IntegerField(
        required=False,
        initial=1,
        widget=NumberInput(attrs={
            'min': 1,
            'max': 65355
        }),
        validators=[MinValueValidator(1),
                    MaxValueValidator(65355)],
        help_text=_t("Specify if column_is varchar"))


ColumnTypeFormSet = simple_formset_factory(ColumnTypeForm,
                                           initial=[{}],
                                           add_label=_t("Add a column"))
# Default to no partitions
PartitionTypeFormSet = simple_formset_factory(PartitionTypeForm,
                                              add_label=_t("Add a partition"))


def _clean_databasename(name):
    try:
        if name in db.get_databases():  # Will always fail
            raise forms.ValidationError(
                _('Database "%(name)s" already exists.') % {'name': name})
    except Exception:
        return name


class CreateDatabaseForm(DependencyAwareForm):
Пример #20
0
 def __init__(self, *args, **kwargs):
     forms.Form.__init__(self, *args, **kwargs)
     self.fields['save'].label = _t('Save')
     self.fields['save'].widget.label = _('Save')
     self.fields['saveas'].label = _t('Save As')
     self.fields['saveas'].widget.label = _('Save As')
Пример #21
0
from desktop import appmanager
from desktop.conf import is_oozie_enabled, has_connectors, is_cm_managed
from desktop.lib.conf import Config, UnspecifiedConfigSection, ConfigSection, coerce_json_dict, coerce_bool, coerce_csv

if sys.version_info[0] > 2:
    from django.utils.translation import gettext_lazy as _t, gettext as _
else:
    from django.utils.translation import ugettext_lazy as _t, ugettext as _

LOG = logging.getLogger(__name__)

# Not used when connector are on
INTERPRETERS_CACHE = None

SHOW_NOTEBOOKS = Config(key="show_notebooks",
                        help=_t("Show the notebook menu or not"),
                        type=coerce_bool,
                        default=True)


def _remove_duplications(a_list):
    return list(OrderedDict.fromkeys(a_list))


def check_has_missing_permission(user, interpreter, user_apps=None):
    # TODO: port to cluster config
    if user_apps is None:
        user_apps = appmanager.get_apps_dict(user)  # Expensive method
    return (interpreter == 'hive' and 'hive' not in user_apps) or \
           (interpreter == 'impala' and 'impala' not in user_apps) or \
           (interpreter == 'pig' and 'pig' not in user_apps) or \
Пример #22
0
import logging
import os
import sys

from django.utils.translation import ugettext_lazy as _t, ugettext as _

from desktop.lib.conf import Config, validate_thrift_transport, coerce_bool
from desktop.lib.exceptions import StructuredThriftTransportException

LOG = logging.getLogger(__name__)


HBASE_CLUSTERS = Config(
  key="hbase_clusters",
  default="(Cluster|localhost:9090)",
  help=_t("Comma-separated list of HBase Thrift servers for clusters in the format of '(name|host:port)'. Use full hostname with security."
          "Prefix hostname with https:// if using SSL and http mode with impersonation."),
  type=str
)

TRUNCATE_LIMIT = Config(
  key="truncate_limit",
  default="500",
  help=_t("Hard limit of rows or columns per row fetched before truncating."),
  type=int
)

THRIFT_TRANSPORT = Config(
  key="thrift_transport",
  default="buffered",
  help=_t("'buffered' is the default of the HBase Thrift Server and supports security. " +
       "'framed' can be used to chunk up responses, " +
Пример #23
0
class UserChangeForm(django.contrib.auth.forms.UserChangeForm):
    """
  This is similar, but not quite the same as djagno.contrib.auth.forms.UserChangeForm
  and UserCreationForm.
  """
    username = forms.RegexField(
        label=_t("Username"),
        max_length=30,
        regex='^%s$' % (get_username_re_rule(), ),
        help_text=_t(
            "Required. 30 characters or fewer. No whitespaces or colons."),
        error_messages={'invalid': _t("Whitespaces and ':' not allowed")})

    password1 = forms.CharField(label=_t("Password"),
                                widget=forms.PasswordInput,
                                required=False,
                                validators=get_password_validators())
    password2 = forms.CharField(label=_t("Password confirmation"),
                                widget=forms.PasswordInput,
                                required=False,
                                validators=get_password_validators())
    password_old = forms.CharField(label=_t("Previous Password"),
                                   widget=forms.PasswordInput,
                                   required=False)
    ensure_home_directory = forms.BooleanField(
        label=_t("Create home directory"),
        help_text=_t("Create home directory if one doesn't already exist."),
        initial=True,
        required=False)

    class Meta(django.contrib.auth.forms.UserChangeForm.Meta):
        fields = [
            "username", "first_name", "last_name", "email",
            "ensure_home_directory"
        ]

    def __init__(self, *args, **kwargs):
        super(UserChangeForm, self).__init__(*args, **kwargs)

        if self.instance.id:
            self.fields['username'].widget.attrs['readonly'] = True

        if desktop_conf.AUTH.BACKEND.get(
        ) == 'desktop.auth.backend.LdapBackend':
            self.fields['password1'].widget.attrs['readonly'] = True
            self.fields['password2'].widget.attrs['readonly'] = True
            self.fields['password_old'].widget.attrs['readonly'] = True

    def clean_password(self):
        return self.cleaned_data["password"]

    def clean_password2(self):
        password1 = self.cleaned_data.get("password1", "")
        password2 = self.cleaned_data["password2"]
        if password1 != password2:
            raise forms.ValidationError(_t("Passwords do not match."))
        return password2

    def clean_password1(self):
        password = self.cleaned_data.get("password1", "")
        if self.instance.id is None and password == "":
            raise forms.ValidationError(
                _("You must specify a password when creating a new user."))
        return self.cleaned_data.get("password1", "")

    def clean_password_old(self):
        if self.instance.id is not None:
            password1 = self.cleaned_data.get("password1", "")
            password_old = self.cleaned_data.get("password_old", "")
            if password1 != '' and not self.instance.check_password(
                    password_old):
                raise forms.ValidationError(
                    _("The old password does not match the current password."))
        return self.cleaned_data.get("password_old", "")

    def save(self, commit=True):
        """
    Update password if it's set.
    """
        user = super(UserChangeForm, self).save(commit=False)
        if self.cleaned_data["password1"]:
            user.set_password(self.cleaned_data["password1"])
        if commit:
            user.save()
            # groups must be saved after the user
            self.save_m2m()
        return user
Пример #24
0
#!/usr/bin/env python
# Licensed to Cloudera, Inc. under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  Cloudera, Inc. licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from django.utils.translation import ugettext as _, ugettext_lazy as _t

from desktop.lib.conf import Config


SERVER_URL = Config(
  key="server_url",
  default='http://localhost:12000/sqoop',
  help=_t("The sqoop server URL."))
Пример #25
0
import sys

from desktop.lib.conf import Config
from liboozie.conf import get_oozie_status

from pig.settings import NICE_NAME

if sys.version_info[0] > 2:
    from django.utils.translation import gettext as _, gettext_lazy as _t
else:
    from django.utils.translation import ugettext as _, ugettext_lazy as _t

LOCAL_SAMPLE_DIR = Config(
    key="local_sample_dir",
    default=os.path.join(os.path.dirname(__file__), "..", "..", "examples"),
    help=_t("Path to directory with piggybank.jar on local filesystem."),
    private=True)

REMOTE_SAMPLE_DIR = Config(
    key="remote_data_dir",
    default="/user/hue/pig/examples",
    help=_t("Location on HDFS where the Pig examples are stored."))


def config_validator(user):
    res = []

    if not 'test' in sys.argv:  # Avoid tests hanging
        status = get_oozie_status(user)

        if 'NORMAL' not in status:
Пример #26
0
from django.utils.translation import ugettext_lazy as _t

from desktop import appmanager
from desktop.conf import is_hue4
from desktop.lib.conf import Config, UnspecifiedConfigSection, ConfigSection,\
  coerce_json_dict, coerce_bool, coerce_csv


def is_oozie_enabled():
  """Oozie needs to be available as it is the backend."""
  return len([app for app in appmanager.DESKTOP_MODULES if app.name == 'oozie']) > 0 and is_hue4()


SHOW_NOTEBOOKS = Config(
    key="show_notebooks",
    help=_t("Show the notebook menu or not"),
    type=coerce_bool,
    default=True
)

def _remove_duplications(a_list):
  return list(OrderedDict.fromkeys(a_list))


def get_ordered_interpreters(user=None):
  if not INTERPRETERS.get():
    _default_interpreters(user)

  interpreters = INTERPRETERS.get()
  interpreters_shown_on_wheel = _remove_duplications(INTERPRETERS_SHOWN_ON_WHEEL.get())
Пример #27
0
class ImportWorkflowForm(WorkflowForm):
    definition_file = forms.FileField(label=_t("Local workflow.xml file"))
    resource_archive = forms.FileField(
        label=_t("Workflow resource archive (zip)"), required=False)
Пример #28
0
 def clean_password2(self):
     password1 = self.cleaned_data.get("password1", "")
     password2 = self.cleaned_data["password2"]
     if password1 != password2:
         raise forms.ValidationError(_t("Passwords do not match."))
     return password2
Пример #29
0
from builtins import str
from past.utils import old_div
import logging
import os.path

from django.utils.translation import ugettext_lazy as _t, ugettext as _

from desktop.conf import default_ssl_cacerts, default_ssl_validate, AUTH_PASSWORD as DEFAULT_AUTH_PASSWORD,\
  AUTH_USERNAME as DEFAULT_AUTH_USERNAME
from desktop.lib.conf import ConfigSection, Config, coerce_bool, coerce_csv, coerce_password_from_script

LOG = logging.getLogger(__name__)

HIVE_DISCOVERY_LLAP = Config(
    key="hive_discovery_llap",
    help=_t(
        "Have Hue determine Hive Server Interactive endpoint from zookeeper"),
    default="false",
    type=coerce_bool)

HIVE_DISCOVERY_HS2 = Config(
    key="hive_discovery_hs2",
    help=_t(
        "Determines whether we pull a random HiveServer2 from the list in zookeeper.  This HS2 instance is cached until hue is restarted."
    ),
    default="false",
    type=coerce_bool)

HIVE_DISCOVERY_LLAP_HA = Config(
    key="hive_discovery_llap_ha",
    help=_t(
        "If you have more than one HSI server, it has a different znode setup.  This will trigger the code to check for the Active HSI Server"
Пример #30
0
        if clusters['default'].HOST_PORTS.get() != 'localhost:2181':
            return '%s/solr' % clusters['default'].HOST_PORTS.get()
    except:
        LOG.warn('Failed to get Zookeeper ensemble')

    try:
        from search.conf import SOLR_URL
        parsed = urlparse(SOLR_URL.get())
        return "%s:2181/solr" % (parsed.hostname or 'localhost')
    except:
        LOG.warn('Failed to get Solr url')


ENABLE_NEW_IMPORTER = Config(
    key="enable_new_importer",
    help=_t("Flag to turn on the new metadata importer."),
    type=bool,
    default=False)

ENABLE_NEW_INDEXER = Config(key="enable_new_indexer",
                            help=_t("Flag to turn on the new Solr indexer."),
                            type=bool,
                            default=True)

CONFIG_INDEXER_LIBS_PATH = Config(
    key="config_indexer_libs_path",
    help=_t("oozie workspace template for indexing:"),
    type=str,
    default='/tmp/smart_indexer_lib')

ENABLE_SQOOP = Config(key="enable_sqoop",
Пример #31
0
class UserProfile(models.Model):
    """
  Extra settings / properties to store for each user.
  """
    class CreationMethod(Enum):
        HUE = 1
        EXTERNAL = 2

    user = models.OneToOneField(User, on_delete=models.CASCADE, unique=True)
    home_directory = models.CharField(editable=True,
                                      max_length=1024,
                                      null=True)
    creation_method = models.CharField(editable=True,
                                       null=False,
                                       max_length=64,
                                       default=CreationMethod.HUE.name)
    first_login = models.BooleanField(
        default=True,
        verbose_name=_t('First Login'),
        help_text=_t('If this is users first login.'))
    last_activity = models.DateTimeField(auto_now=True, db_index=True)
    hostname = models.CharField(editable=True, max_length=255, null=True)
    json_data = models.TextField(default='{}')

    def get_groups(self):
        return self.user.groups.all()

    def _lookup_permission(self, app, action):
        # We cache it instead of doing HuePermission.objects.get(app=app, action=action). To revert with Django 1.6
        perms = cache.get('perms')
        if not perms:
            perms = dict([('%s:%s' % (p.app, p.action), p)
                          for p in HuePermission.objects.all()])
            cache.set('perms', perms, 60 * 60)
        return perms.get('%s:%s' % (app, action))

    def has_hue_permission(self, action=None, app=None, perm=None):
        if perm is None:
            try:
                perm = self._lookup_permission(app, action)
            except HuePermission.DoesNotExist:
                LOG.exception(
                    "Permission object %s - %s not available. Was Django migrate command run after installation?"
                    % (app, action))
                return self.user.is_superuser
        if self.user.is_superuser:
            return True
        if ENABLE_CONNECTORS.get() and app in ('jobbrowser', 'metastore',
                                               'filebrowser', 'indexer',
                                               'useradmin', 'notebook'):
            if app == 'useradmin' and action in (
                    'superuser',
                    'access_view:useradmin:edit_user'):  # Not implemented yet
                return False
            else:
                return True

        group_ids = self.user.groups.values_list('id', flat=True)
        return GroupPermission.objects.filter(group__id__in=group_ids,
                                              hue_permission=perm).exists()

    def get_permissions(self):
        return HuePermission.objects.filter(groups__user=self.user)

    def check_hue_permission(self, perm=None, app=None, action=None):
        """
    Raises a PopupException if permission is denied.

    Either perm or both app and action are required.
    """
        if perm is None:
            perm = self._lookup_permission(app, action)
        if self.has_hue_permission(perm):
            return
        else:
            raise PopupException(
                _t("You do not have permissions to %(description)s.") %
                {'description': perm.description})

    @property
    def data(self):
        if not self.json_data:
            self.json_data = json.dumps({})
        return json.loads(self.json_data)

    def update_data(self, val):
        data_dict = self.data
        data_dict.update(val)
        self.json_data = json.dumps(data_dict)
Пример #32
0
 def __init__(self, *args, **kwargs):
   super(LdapAuthenticationForm, self).__init__(*args, **kwargs)
   self.fields['server'] = ChoiceField(choices=get_server_choices())
   self.error_messages['invalid_login'] = _t("Invalid username or password, or your LDAP groups not allowed")
Пример #33
0
Файл: conf.py Проект: ktham/hue
def dict_list_map(value):
    if isinstance(value, str):
        d = {}
        for k, v in json.loads(value).iteritems():
            d[k] = (v,)
        return d
    elif isinstance(value, dict):
        return value
    return None


XMLSEC_BINARY = Config(
    key="xmlsec_binary",
    default="/usr/local/bin/xmlsec1",
    type=str,
    help=_t("Xmlsec1 binary path. This program should be executable by the user running Hue."),
)

CREATE_USERS_ON_LOGIN = Config(
    key="create_users_on_login", default=True, type=coerce_bool, help=_t("Create users from IdP on login.")
)

ATTRIBUTE_MAP_DIR = Config(
    key="attribute_map_dir",
    default=os.path.abspath(os.path.join(BASEDIR, "..", "..", "attribute-maps")),
    type=str,
    private=True,
    help=_t("Attribute map directory contains files that map SAML attributes to pysaml2 attributes."),
)

ALLOW_UNSOLICITED = Config(
Пример #34
0
from desktop.lib.conf import Config, UnspecifiedConfigSection, ConfigSection, coerce_bool
from desktop.appmanager import get_apps_dict
from notebook.conf import get_ordered_interpreters



def is_enabled():
  """Automatic when search is enabled."""
  apps = get_apps_dict()

  return 'search' in apps or HAS_SQL_ENABLED.get()


IS_ENABLED = Config(
  key="is_enabled",
  help=_t("Activate the Dashboard link in the menu."),
  dynamic_default=is_enabled,
  type=coerce_bool
)

HAS_SQL_ENABLED = Config(
  key="has_sql_enabled",
  help=_t("Activate the SQL Dashboard (beta)."),
  default=False,
  type=coerce_bool
)

HAS_QUERY_BUILDER_ENABLED = Config(
  key="has_query_builder_enabled",
  help=_t("Activate the Query Builder (beta)."),
  default=False,
Пример #35
0
    ("column_type", "map", "map_key_type"),
    ("column_type", "map", "map_value_type"),
  ]
  column_name = common.HiveIdentifierField(label=_t('Column Name'), required=True)
  column_type = forms.ChoiceField(label=_t('Column Type'), required=True,
    choices=common.to_choices(HIVE_TYPES))
  array_type = forms.ChoiceField(required=False,
    choices=common.to_choices(HIVE_PRIMITIVE_TYPES), label=_t("Array Value Type"))
  map_key_type = forms.ChoiceField(required=False,
                                   choices=common.to_choices(HIVE_PRIMITIVE_TYPES),
                                   help_text=_t("Specify if column_type is map."))
  map_value_type = forms.ChoiceField(required=False,
                                     choices=common.to_choices(HIVE_PRIMITIVE_TYPES),
                                     help_text=_t("Specify if column_type is map."))

ColumnTypeFormSet = simple_formset_factory(ColumnTypeForm, initial=[{}], add_label=_t("add a column"))
# Default to no partitions
PartitionTypeFormSet = simple_formset_factory(PartitionTypeForm, add_label=_t("add a partition"))


class LoadDataForm(forms.Form):
  """Form used for loading data into an existing table."""
  path = PathField(label=_t("Path"))
  overwrite = forms.BooleanField(required=False, initial=False, label=_t("Overwrite?"))

  def __init__(self, table_obj, *args, **kwargs):
    """
    @param table_obj is a hive_metastore.thrift Table object,
    used to add fields corresponding to partition keys.
    """
    super(LoadDataForm, self).__init__(*args, **kwargs)
Пример #36
0
import logging

from django.utils.translation import ugettext_lazy as _t

from desktop.lib.conf import Config, ConfigSection, coerce_bool

LOG = logging.getLogger(__name__)


def has_kafka():
    return KAFKA.IS_ENABLED.get()


def has_kafka_api():
    return bool(KAFKA.API_URL.get())


KAFKA = ConfigSection(
    key='kafka',
    help=_t("""Configuration options for Kafka API integration"""),
    members=dict(
        IS_ENABLED=Config(key="is_enabled",
                          help=_t("Enable the Kafka integration."),
                          type=coerce_bool,
                          default=False),
        API_URL=Config(key='api_url',
                       help=_t('Base URL of Kafka REST API.'),
                       default=None),
    ))
Пример #37
0
from django.utils.translation import ugettext_lazy as _t, ugettext as _

from desktop.conf import default_ssl_cacerts, default_ssl_validate, AUTH_PASSWORD as DEFAULT_AUTH_PASSWORD,\
  AUTH_USERNAME as DEFAULT_AUTH_USERNAME
from desktop.lib.conf import ConfigSection, Config, coerce_bool, coerce_password_from_script
from desktop.lib.exceptions import StructuredThriftTransportException

from beeswax.settings import NICE_NAME

LOG = logging.getLogger(__name__)


HIVE_SERVER_HOST = Config(
  key="hive_server_host",
  help=_t("Host where HiveServer2 server is running. If Kerberos security is enabled, "
         "the fully-qualified domain name (FQDN) is required"),
  default="localhost")

HIVE_SERVER_PORT = Config(
  key="hive_server_port",
  help=_t("Configure the port the HiveServer2 server runs on."),
  default=10000,
  type=int)

HIVE_CONF_DIR = Config(
  key='hive_conf_dir',
  help=_t('Hive configuration directory, where hive-site.xml is located.'),
  default=os.environ.get("HIVE_CONF_DIR", '/etc/hive/conf'))

HIVE_SERVER_BIN = Config(
  key="hive_server_bin",
Пример #38
0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import sys
import socket

from django.utils.translation import ugettext_lazy as _t, ugettext as _
from desktop.lib.conf import ConfigSection, Config, coerce_bool

from impala.settings import NICE_NAME

SERVER_HOST = Config(key="server_host",
                     help=_t("Host of the Impala Server."),
                     default="localhost")

SERVER_PORT = Config(key="server_port",
                     help=_t("Port of the Impala Server."),
                     default=21050,
                     type=int)

IMPALA_PRINCIPAL = Config(
    key='impala_principal',
    help=_t(
        "Kerberos principal name for Impala. Typically 'impala/hostname.foo.com'."
    ),
    type=str,
    default="impala/%s" % socket.getfqdn())
Пример #39
0
 class Meta:
     abstract = True
     verbose_name = _t('connector')
     verbose_name_plural = _t('connectors')
     unique_together = ('name', )
Пример #40
0
 def __init__(self, *args, **kwargs):
   forms.Form.__init__(self, *args, **kwargs)
   self.fields['save'].label = _t('Save')
   self.fields['save'].widget.label = _('Save')
   self.fields['saveas'].label = _t('Save As')
   self.fields['saveas'].widget.label = _('Save As')
Пример #41
0
import os.path

from django.utils.translation import ugettext as _, ugettext_lazy as _t

from desktop.lib.conf import Config, coerce_bool
from desktop.lib import paths
from liboozie.conf import get_oozie_status

from oozie.settings import NICE_NAME

DEFINITION_XSLT_DIR = Config(
    key="definition_xslt_dir",
    default=os.path.join(os.path.dirname(__file__), "importlib", "xslt"),
    help=_t(
        "Location on local FS where the xslt files are stored for workflow import."
    ),
    private=True)

DEFINITION_XSLT2_DIR = Config(
    key="definition_xslt2_dir",
    default=os.path.join(os.path.dirname(__file__), "importlib", "xslt2"),
    help=_t(
        "Location on local FS where the xslt files are stored for workflow import."
    ),
    private=True)

LOCAL_SAMPLE_DIR = Config(
    key="local_data_dir",
    default=os.path.join(os.path.dirname(__file__), "..", "..", "examples"),
    help=_t("Location on local filesystem where the examples are stored."),
Пример #42
0
 def clean_password2(self):
   password1 = self.cleaned_data.get("password1", "")
   password2 = self.cleaned_data["password2"]
   if password1 != password2:
     raise forms.ValidationError(_t("Passwords do not match."))
   return password2
Пример #43
0
class CreateTableForm(DependencyAwareForm):
    """
  Form used in the create table page
  """
    dependencies = []

    # Basic Data
    name = common.HiveIdentifierField(label=_t("Table Name"), required=True)
    comment = forms.CharField(label=_t("Description"), required=False)

    # Row Formatting
    row_format = forms.ChoiceField(required=True,
                                   choices=common.to_choices(
                                       ["Delimited", "SerDe"]),
                                   initial="Delimited")

    # Delimited Row
    # These initials are per LazySimpleSerDe.DefaultSeparators
    field_terminator = ChoiceOrOtherField(label=_t("Field terminator"),
                                          required=False,
                                          initial=TERMINATOR_CHOICES[0][0],
                                          choices=TERMINATOR_CHOICES)
    collection_terminator = ChoiceOrOtherField(
        label=_t("Collection terminator"),
        required=False,
        initial=TERMINATOR_CHOICES[1][0],
        choices=TERMINATOR_CHOICES)
    map_key_terminator = ChoiceOrOtherField(label=_t("Map key terminator"),
                                            required=False,
                                            initial=TERMINATOR_CHOICES[2][0],
                                            choices=TERMINATOR_CHOICES)
    dependencies += [
        ("row_format", "Delimited", "field_terminator"),
        ("row_format", "Delimited", "collection_terminator"),
        ("row_format", "Delimited", "map_key_terminator"),
    ]

    # Serde Row
    serde_name = forms.CharField(required=False, label=_t("SerDe Name"))
    serde_properties = forms.CharField(
        required=False,
        help_text=_t(
            "Comma-separated list of key-value pairs. E.g. 'p1=v1, p2=v2'"))

    dependencies += [
        ("row_format", "SerDe", "serde_name"),
        ("row_format", "SerDe", "serde_properties"),
    ]

    # File Format
    file_format = forms.ChoiceField(
        required=False,
        initial="TextFile",
        choices=common.to_choices(["TextFile", "SequenceFile", "InputFormat"]),
        widget=forms.RadioSelect)
    input_format_class = forms.CharField(required=False,
                                         label=_t("InputFormat Class"))
    output_format_class = forms.CharField(required=False,
                                          label=_t("OutputFormat Class"))

    dependencies += [
        ("file_format", "InputFormat", "input_format_class"),
        ("file_format", "InputFormat", "output_format_class"),
    ]

    # External?
    use_default_location = forms.BooleanField(
        required=False, initial=True, label=_t("Use default location."))
    external_location = forms.CharField(
        required=False,
        help_text=_t("Path to HDFS directory or file of table data."))

    dependencies += [("use_default_location", False, "external_location")]

    def clean_field_terminator(self):
        return _clean_terminator(self.cleaned_data.get('field_terminator'))

    def clean_collection_terminator(self):
        return _clean_terminator(
            self.cleaned_data.get('collection_terminator'))

    def clean_map_key_terminator(self):
        return _clean_terminator(self.cleaned_data.get('map_key_terminator'))

    def clean_name(self):
        return _clean_tablename(self.db, self.cleaned_data['name'],
                                self.database)
Пример #44
0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import sys

from django.utils.translation import ugettext as _, ugettext_lazy as _t

from desktop.lib.conf import Config, coerce_bool, validate_path

OOZIE_URL = Config(
    key='oozie_url',
    help=_t('URL of Oozie server. This is required for job submission.'),
    default='http://localhost:11000/oozie',
    type=str)

SECURITY_ENABLED = Config(
    key="security_enabled",
    help=_t(
        "Whether Oozie requires client to perform Kerberos authentication."),
    default=False,
    type=coerce_bool)

REMOTE_DEPLOYMENT_DIR = Config(
    key="remote_deployement_dir",
    default="/user/hue/oozie/deployments",
    help=_t(
        "Location on HDFS where the workflows/coordinators are deployed when submitted by a non-owner."
Пример #45
0
class SavedQuery(models.Model):
    """
  Stores the query that people have save or submitted.

  Note that this used to be called QueryDesign. Any references to 'design'
  probably mean a SavedQuery.
  """
    DEFAULT_NEW_DESIGN_NAME = _('My saved query')
    AUTO_DESIGN_SUFFIX = _(' (new)')
    TYPES = QUERY_TYPES
    TYPES_MAPPING = {
        'beeswax': HQL,
        'hql': HQL,
        'impala': IMPALA,
        'rdbms': RDBMS,
        'spark': SPARK
    }

    type = models.IntegerField(null=False)
    owner = models.ForeignKey(User, db_index=True)
    # Data is a json of dictionary. See the beeswax.design module.
    data = models.TextField(max_length=65536)
    name = models.CharField(max_length=80)
    desc = models.TextField(max_length=1024)
    mtime = models.DateTimeField(auto_now=True)
    # An auto design is a place-holder for things users submit but not saved.
    # We still want to store it as a design to allow users to save them later.
    is_auto = models.BooleanField(default=False, db_index=True)
    is_trashed = models.BooleanField(default=False,
                                     db_index=True,
                                     verbose_name=_t('Is trashed'),
                                     help_text=_t('If this query is trashed.'))

    is_redacted = models.BooleanField(default=False)

    doc = generic.GenericRelation(Document, related_name='hql_doc')

    class Meta:
        ordering = ['-mtime']

    def get_design(self):
        try:
            return HQLdesign.loads(self.data)
        except ValueError:
            # data is empty
            pass

    def clone(self, new_owner=None):
        if new_owner is None:
            new_owner = self.owner
        design = SavedQuery(type=self.type, owner=new_owner)
        design.data = self.data
        design.name = self.name
        design.desc = self.desc
        design.is_auto = self.is_auto
        return design

    @classmethod
    def create_empty(cls, app_name, owner, data):
        query_type = SavedQuery.TYPES_MAPPING[app_name]
        design = SavedQuery(owner=owner, type=query_type)
        design.name = SavedQuery.DEFAULT_NEW_DESIGN_NAME
        design.desc = ''

        if global_redaction_engine.is_enabled():
            design.data = global_redaction_engine.redact(data)
        else:
            design.data = data

        design.is_auto = True
        design.save()

        Document.objects.link(design,
                              owner=design.owner,
                              extra=design.type,
                              name=design.name,
                              description=design.desc)
        design.doc.get().add_to_history()

        return design

    @staticmethod
    def get(id, owner=None, type=None):
        """
    get(id, owner=None, type=None) -> SavedQuery object

    Checks that the owner and type match (when given).
    May raise PopupException (type/owner mismatch).
    May raise SavedQuery.DoesNotExist.
    """
        try:
            design = SavedQuery.objects.get(id=id)
        except SavedQuery.DoesNotExist, err:
            msg = _('Cannot retrieve query id %(id)s.') % {'id': id}
            raise err

        if owner is not None and design.owner != owner:
            msg = _('Query id %(id)s does not belong to user %(user)s.') % {
                'id': id,
                'user': owner
            }
            LOG.error(msg)
            raise PopupException(msg)

        if type is not None and design.type != type:
            msg = _('Type mismatch for design id %(id)s (owner %(owner)s) - Expected %(expected_type)s, got %(real_type)s.') % \
                  {'id': id, 'owner': owner, 'expected_type': design.type, 'real_type': type}
            LOG.error(msg)
            raise PopupException(msg)

        return design
Пример #46
0
    return is_enabled()


def get_optimizer_password_script():
    '''Get default password from secured file'''
    global OPTIMIZER_AUTH_PASSWORD

    if OPTIMIZER_AUTH_PASSWORD is None:
        OPTIMIZER_AUTH_PASSWORD = OPTIMIZER.AUTH_KEY_SECRET_SCRIPT.get()

    return OPTIMIZER_AUTH_PASSWORD


OPTIMIZER = ConfigSection(
    key='optimizer',
    help=_t("""Configuration options for Optimizer API"""),
    members=dict(
        INTERFACE=Config(
            key='interface',
            help=_t(
                'Type of Optimizer to connect to, e.g. Navigator Optimizer...'
            ),
            default='optimizer'),
        HOSTNAME=Config(
            key='hostname',
            help=_t('Hostname to Optimizer API or compatible service.'),
            default='navoptapi.us-west-1.optimizer.altus.cloudera.com'),
        AUTH_KEY_ID=Config(key="auth_key_id",
                           help=_t("The name of the key of the service."),
                           private=False,
                           default=None),
Пример #47
0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import sys

from django.utils.translation import ugettext as _, ugettext_lazy as _t

from desktop.lib.conf import Config, coerce_bool, validate_path


OOZIE_URL = Config(
  key='oozie_url',
  help=_t('URL of Oozie server. This is required for job submission. Empty value disables the config check.'),
  default='http://localhost:11000/oozie',
  type=str)

SECURITY_ENABLED = Config(
  key="security_enabled",
  help=_t("Whether Oozie requires client to perform Kerberos authentication."),
  default=False,
  type=coerce_bool)

REMOTE_DEPLOYMENT_DIR = Config(
  key="remote_deployement_dir",
  default="/user/hue/oozie/deployments/_$USER_-oozie-$JOBID-$TIME",
  help=_t("Location on HDFS where the workflows/coordinators are deployed when submitted by a non-owner."
          " Parameters are $TIME, $USER and $JOBID, e.g. /user/$USER/hue/deployments/$JOBID-$TIME"))
Пример #48
0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import sys

from django.utils.translation import ugettext_lazy as _t, ugettext as _

from desktop.lib.conf import Config
from spark.settings import NICE_NAME

JOB_SERVER_URL = Config(key="server_url",
                        help=_t("URL of the Spark Job Server."),
                        default="http://localhost:8090/")


def get_spark_status(user):
    from spark.job_server_api import get_api
    status = None

    try:
        if not 'test' in sys.argv:  # Avoid tests hanging
            status = str(get_api(user).get_status())
    except ValueError:
        # No json returned
        status = 'OK'
    except:
        pass
Пример #49
0
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import sys
import socket

from django.utils.translation import ugettext_lazy as _t, ugettext as _
from desktop.lib.conf import Config, coerce_bool

from impala.settings import NICE_NAME


SERVER_HOST = Config(
  key="server_host",
  help=_t("Host of the Impala Server."),
  default="localhost")

SERVER_PORT = Config(
  key="server_port",
  help=_t("Port of the Impala Server."),
  default=21050,
  type=int)

IMPALA_PRINCIPAL=Config(
  key='impala_principal',
  help=_t("Kerberos principal name for Impala. Typically 'impala/hostname.foo.com'."),
  type=str,
  default="impala/%s" % socket.getfqdn())

IMPERSONATION_ENABLED=Config(
Пример #50
0
from libzookeeper.conf import ENSEMBLE

if sys.version_info[0] > 2:
  from urllib.parse import urlparse
  new_str = str
  from django.utils.translation import gettext_lazy as _t
else:
  from django.utils.translation import ugettext_lazy as _t
  from urlparse import urlparse

LOG = logging.getLogger(__name__)


SSL_CERT_CA_VERIFY = Config(
  key="ssl_cert_ca_verify",
  help=_t("In secure mode (HTTPS), if Solr SSL certificates have to be verified against certificate authority"),
  dynamic_default=default_ssl_validate,
  type=coerce_bool
)


def zkensemble_path():
  """
  Try to guess Solr path in ZooKeeper.
  """
  try:
    parsed = urlparse(ENSEMBLE.get())
    if parsed.port == 9983: # Standalone Solr cloud
      return ''
  except:
    LOG.warning('Failed to get Zookeeper ensemble path')
Пример #51
0
import os.path

from django.utils.translation import ugettext as _, ugettext_lazy as _t

from desktop.lib.conf import Config, coerce_bool
from desktop.lib import paths
from liboozie.conf import get_oozie_status

from oozie.settings import NICE_NAME


DEFINITION_XSLT_DIR = Config(
  key="definition_xslt_dir",
  default=os.path.join(os.path.dirname(__file__), "importlib", "xslt"),
  help=_t("Location on local FS where the xslt files are stored for workflow import."),
  private=True
)

LOCAL_SAMPLE_DIR = Config(
  key="local_data_dir",
  default=os.path.join(os.path.dirname(__file__), "..", "..", "examples"),
  help=_t("Location on local filesystem where the examples are stored."),
  private=True
)

LOCAL_SAMPLE_DATA_DIR = Config(
  key="sample_data_dir",
  default=paths.get_thirdparty_root("sample_data"),
  help=_t("Location on local filesystem where the data for the examples is stored."),
  private=True
Пример #52
0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import sys

from django.utils.translation import ugettext as _, ugettext_lazy as _t

from desktop.lib.conf import Config, coerce_bool, validate_path

OOZIE_URL = Config(
    key='oozie_url',
    help=_t(
        'URL of Oozie server. This is required for job submission. Empty value disables the config check.'
    ),
    default='http://localhost:11000/oozie',
    type=str)

SECURITY_ENABLED = Config(
    key="security_enabled",
    help=_t(
        "Whether Oozie requires client to perform Kerberos authentication."),
    default=False,
    type=coerce_bool)

REMOTE_DEPLOYMENT_DIR = Config(
    key="remote_deployement_dir",
    default="/user/hue/oozie/deployments/_$USER_-oozie-$JOBID-$TIME",
    help=_t(
Пример #53
0
# limitations under the License.

import os.path
import sys
import beeswax.hive_site

from django.utils.translation import ugettext_lazy as _t, ugettext as _

from desktop.lib.conf import ConfigSection, Config, coerce_bool

from beeswax.settings import NICE_NAME


HIVE_SERVER_HOST = Config(
  key="hive_server_host",
  help=_t("Host where HiveServer2 server is running. If Kerberos security is enabled, "
         "the fully-qualified domain name (FQDN) is required"),
  default="localhost")

HIVE_SERVER_PORT = Config(
  key="hive_server_port",
  help=_t("Configure the port the HiveServer2 server runs on."),
  default=10000,
  type=int)

HIVE_CONF_DIR = Config(
  key='hive_conf_dir',
  help=_t('Hive configuration directory, where hive-site.xml is located.'),
  default=os.environ.get("HIVE_CONF_DIR", '/etc/hive/conf'))

HIVE_SERVER_BIN = Config(
  key="hive_server_bin",
Пример #54
0
# limitations under the License.

import os.path
import sys
import beeswax.hive_site

from django.utils.translation import ugettext_lazy as _t, ugettext as _

from desktop.lib.conf import ConfigSection, Config, coerce_bool

from beeswax.settings import NICE_NAME

HIVE_SERVER_HOST = Config(
    key="hive_server_host",
    help=_t(
        "Host where HiveServer2 server is running. If Kerberos security is enabled, "
        "the fully-qualified domain name (FQDN) is required"),
    default="localhost")

HIVE_SERVER_PORT = Config(
    key="hive_server_port",
    help=_t("Configure the port the HiveServer2 server runs on."),
    default=10000,
    type=int)

HIVE_CONF_DIR = Config(
    key='hive_conf_dir',
    help=_t('Hive configuration directory, where hive-site.xml is located.'),
    default=os.environ.get("HIVE_CONF_DIR", '/etc/hive/conf'))

HIVE_SERVER_BIN = Config(key="hive_server_bin",
Пример #55
0
class AuthenticationForm(AuthAuthenticationForm):
  """
  Adds appropriate classes to authentication form
  """
  username = CharField(label=_t("Username"), max_length=30, widget=TextInput(attrs={'class': 'input-large', 'maxlength': 30}))
  password = CharField(label=_t("Password"), widget=PasswordInput(attrs={'class': 'input-large', 'maxlength': 30}))
Пример #56
0
class AddLdapGroupsForm(forms.Form):
    groupname_pattern = forms.CharField(
        label=_t("Name"),
        max_length=256,
        help_text=_t("Required. 256 characters or fewer."),
        error_messages={'invalid': _t("256 characters or fewer.")})
    dn = forms.BooleanField(
        label=_t("Distinguished name"),
        help_text=_t("Whether or not the group should be imported by "
                     "distinguished name."),
        initial=False,
        required=False)
    import_members = forms.BooleanField(
        label=_t('Import new members'),
        help_text=_t('Import unimported or new users from the group.'),
        initial=False,
        required=False)
    ensure_home_directories = forms.BooleanField(
        label=_t('Create home directories'),
        help_text=_t(
            'Create home directories for every member imported, if members are being imported.'
        ),
        initial=True,
        required=False)
    import_members_recursive = forms.BooleanField(
        label=_t('Import new members from all subgroups'),
        help_text=_t('Import unimported or new users from the all subgroups.'),
        initial=False,
        required=False)

    def __init__(self, *args, **kwargs):
        super(AddLdapGroupsForm, self).__init__(*args, **kwargs)
        if get_server_choices():
            self.fields['server'] = forms.ChoiceField(
                choices=get_server_choices(), required=True)

    def clean(self):
        cleaned_data = super(AddLdapGroupsForm, self).clean()
        groupname_pattern = cleaned_data.get("groupname_pattern")
        dn = cleaned_data.get("dn")

        try:
            if dn:
                validate_dn(groupname_pattern)
            else:
                validate_groupname(groupname_pattern)
        except AssertionError, e:
            errors = self._errors.setdefault('groupname_pattern', ErrorList())
            errors.append(e.message)
            raise forms.ValidationError(e.message)

        return cleaned_data
Пример #57
0
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import sys
import socket

from django.utils.translation import ugettext_lazy as _t, ugettext as _
from desktop.lib.conf import Config

from impala.settings import NICE_NAME


SERVER_HOST = Config(
  key="server_host",
  help=_t("Host of the Impala Server."),
  default="localhost")

SERVER_PORT = Config(
  key="server_port",
  help=_t("Port of the Impala Server."),
  default=21050,
  type=int)

SERVER_INTERFACE = Config(
  key="server_interface",
  help=_t("Beeswax or Hive Server 2 Thrift API used. Choices are: 'beeswax' or 'hiveserver2'."),
  default="hiveserver2")

IMPALA_PRINCIPAL=Config(
  key='impala_principal',
Пример #58
0
from builtins import oct
from builtins import object
import logging
import sys

from django.utils.translation import ugettext as _, ugettext_lazy as _t

from desktop.conf import default_ssl_validate
from desktop.lib.conf import Config, coerce_bool, validate_path

LOG = logging.getLogger(__name__)

OOZIE_URL = Config(
    key='oozie_url',
    help=_t(
        'URL of Oozie server. This is required for job submission. Empty value disables the config check.'
    ),
    default='http://localhost:11000/oozie',
    type=str)

SECURITY_ENABLED = Config(
    key="security_enabled",
    help=_t(
        "Whether Oozie requires client to perform Kerberos authentication."),
    default=False,
    type=coerce_bool)

REMOTE_DEPLOYMENT_DIR = Config(
    key="remote_deployement_dir",
    default="/user/hue/oozie/deployments/_$USER_-oozie-$JOBID-$TIME",
    help=_t(
Пример #59
0

def dict_list_map(value):
    if isinstance(value, str):
        d = json.loads(value)
        return {k: (v,) for k, v in d.iteritems()}
    elif isinstance(value, dict):
        return value
    return None


XMLSEC_BINARY = Config(
    key="xmlsec_binary",
    default="/usr/local/bin/xmlsec1",
    type=str,
    help=_t("Xmlsec1 binary path. This program should be executable by the user running Hue."),
)

CREATE_USERS_ON_LOGIN = Config(
    key="create_users_on_login", default=True, type=coerce_bool, help=_t("Create users from IdP on login.")
)

ENTITY_ID = Config(
    key="entity_id",
    default="http://localhost:8888/saml2/metadata/",
    type=str,
    help=_t("Globally unique identifier of the entity."),
)

ATTRIBUTE_MAP_DIR = Config(
    key="attribute_map_dir",
Пример #60
0
        if clusters['default'].HOST_PORTS.get() != 'localhost:2181':
            return '%s/solr' % clusters['default'].HOST_PORTS.get()
    except:
        LOG.warn('Failed to get Zookeeper ensemble')

    try:
        from search.conf import SOLR_URL
        parsed = urlparse(SOLR_URL.get())
        return "%s:2181/solr" % (parsed.hostname or 'localhost')
    except:
        LOG.warn('Failed to get Solr url')


# Deprecated as always on
ENABLE_NEW_INDEXER = Config(key="enable_new_indexer",
                            help=_t("Flag to turn on the new Solr indexer."),
                            type=bool,
                            default=True)

ENABLE_SCALABLE_INDEXER = Config(
    key="enable_scalable_indexer",
    help=_t("Flag to turn on the Morphline Solr indexer."),
    type=bool,
    default=True)

CONFIG_INDEXER_LIBS_PATH = Config(
    key="config_indexer_libs_path",
    help=_t("Filesystem directory containing Solr Morphline indexing libs."),
    type=str,
    default='/tmp/smart_indexer_lib')