text: # Copyright 2016, 2017 Suomi Corporation
  #
  # Licensed under the Apache License, Version 2.0 (the "License");
  # you may not use this file except in compliance with the License.
  # You may obtain a copy of the License at
  #
  #     http://www.apache.org/licenses/LICENSE-2.0
  #
  # Unless required by applicable law or agreed to in writing, software
  # distributed under the License is distributed on an "AS IS" BASIS,
  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  # See the License for the specific language governing permissions and
  # limitations under the License.
  # ------------------------------------------------------------------------------
  
  import logging
  import os
  
  import suomi_signing as signing
  from suomi_signing import CryptoFactory
  from suomi_signing.secp256k1 import Secp256k1PrivateKey
  from suomi_validator.exceptions import LocalConfigurationError
  
  LOGGER = logging.getLogger(__name__)
  
  
  def load_identity_signer(key_dir, key_name):
      """Loads a private key from the key directory, based on a validator's
      identity.
  
      Args:
          key_dir (str): The path to the key directory.
          key_name (str): The name of the key to load.
  
      Returns:
          Signer: the cryptographic signer for the key
      """
      key_path = os.path.join(key_dir, '{}.priv'.format(key_name))
  
      if not os.path.exists(key_path):
          raise LocalConfigurationError(
              "No such signing key file: {}".format(key_path))
      if not os.access(key_path, os.R_OK):
          raise LocalConfigurationError(
              "Key file is not readable: {}".format(key_path))
  
      LOGGER.info('Loading signing key: %s', key_path)
      try:
          with open(key_path, 'r') as key_file:
              private_key_str = key_file.read().strip()
      except IOError as e:
          raise LocalConfigurationError(
              "Could not load key file: {}".format(str(e)))
  
      try:
          private_key = Secp256k1PrivateKey.from_hex(private_key_str)
      except signing.ParseError as e:
          raise LocalConfigurationError(
              "Invalid key in file {}: {}".format(key_path, str(e)))
  
      context = signing.create_context('secp256k1')
      crypto_factory = CryptoFactory(context)
      return crypto_factory.new_signer(private_key)
  