saltstack / salt Goto Github PK

Think of a module? Make it!

In particular cython support has not been working on some nodes and I don't know why.
Also, test everything

Generate a report of what jobs have run and what the results are

If no minions return then the client should global timeout

Salt needs logging, a lot of logging!

so I can have a subdir named foo with a module named bar and a function named baz
so the lookup will be foo.bar.baz

The salt minion config should have an id, not a hostname

We want to be able to turn off certain modules on certain hosts via the minion config

Catch faulty calls

so it looks nice

I want to figure out how to make a salt cluster of masters

Salt needs to be able to do basic ftp

The master server's return can't keep up with a lot of large returns containing a lot of data. We need to explore how to make this run faster

because I would like to have modules that fail due to deps, also, I want to be able to load non-python modules, I don't think that should be to hard, just some metaprogramming

the minion can be "id"-ed with the hostname value right now. But I want to be able to access minions based on Facter data, this means that the facter data needs to be moved into the config.py module and included as part of the opts variable.
This also means that other forms of data should be accesible from config in the futue.

Add an option to print out the minion public key

The master loop needs to scan the old salt jobs periodically and clean out the ones that are old

This module always needs more :) list what has been added here

Make sure that when a master is restarted the minions still work without requiring a restart

because that would be nice

Make it so that a list of module directories can be loaded into the minion. This will allow third party module devs to add modules without adding them to the python site-packages.

need a flag to use pcre regex on the salt cli

This may be pie in the sky, but I want to be able to execute multiple commands on the minions without having to execute multiple publishes

Right now in the minion when a publication is matched the execution happens in a thread. This should be configurable to execute in a multiprocess, so we need to add the option to the config, import multiprocessing in a try block and fall back to threading is multiprocessing is not available

Create a test module for pings and like operations

If I have correctly read the code salt-master not only reads the master config file but also the minion configuration. With the "config" option you can only choose another master configuration file. The following is just an idea and not very well tested.

 The patch changes the behavior of the "config" option. It points now
 to the config dir and assumes, that the config files are named "master"
 and "minion".

 Signed-off-by: Matthias Teege <[email protected]>
 ---
  salt/__init__.py |    8 ++++----
  salt/master.py   |    2 +-
  2 files changed, 5 insertions(+), 5 deletions(-)

 diff --git a/salt/__init__.py b/salt/__init__.py
 index 7572fc8..3ac2202 100644
 --- a/salt/__init__.py
 +++ b/salt/__init__.py
 @@ -25,7 +25,7 @@ class Master(object):
      '''
      def __init__(self):
          self.cli = self.__parse_cli()
 -        self.opts = salt.config.master_config(self.cli['config'])
 +        self.opts = salt.config.master_config(self.cli['config'] + '/master')

      def __parse_cli(self):
          '''
 @@ -41,7 +41,7 @@ class Master(object):
          parser.add_option('-c',
                  '--config',
                  dest='config',
 -                default='/etc/salt/master',
 +                default='/etc/salt',
                  help='Pass in an alternative configuration file')

          options, args = parser.parse_args()
 @@ -70,7 +70,7 @@ class Minion(object):
      '''
      def __init__(self):
          self.cli = self.__parse_cli()
 -        self.opts = salt.config.minion_config(self.cli['config'])
 +        self.opts = salt.config.minion_config(self.cli['config'] + '/minion')

      def __parse_cli(self):
          '''
 @@ -86,7 +86,7 @@ class Minion(object):
          parser.add_option('-c',
                  '--config',
                  dest='config',
 -                default='/etc/salt/minion',
 +                default='/etc/salt',
                  help='Pass in an alternative configuration file')

          options, args = parser.parse_args()
 diff --git a/salt/master.py b/salt/master.py
 index 01b4cc5..d6fe85e 100644
 --- a/salt/master.py
 +++ b/salt/master.py
 @@ -112,7 +112,7 @@ class ReqServer(threading.Thread):
          self.key = self.__prep_key()
          self.crypticle = salt.crypt.Crypticle(self.opts['aes'])
          # Make a client
 -        self.local = salt.client.LocalClient()
 +        self.local = salt.client.LocalClient(opts['conf_file'])

      def __prep_key(self):
          '''
 -- 
 1.7.3.4

this is unacceptable, also since the master needs to be portable. Need to make the minions persist

make salt be able to make json output

a sys function needs to report on all available functions and pass on the documentation on how to use them

Fill out the cmd module for shell out operations

Right now only a local client can publish, I need to figure out how to create remote clients so that distributed applications can use salt as a command broker.

Right now I think the only requirement for python 2.7 is importlib, and you can do this with import
2.6 means we can at least get salt running on rhel6, I want rhel5 support, python 2.4

Or continue on with requiring python3....

The minion will need to be able to execute some simple introspection reporting, this will need to make a "built in" function set appended to the functions dict

Need to be able to pass an explicit list of servers into the client

Add the capability to match hosts based on information gathered from and arbitrairy execution

The timeout algorithm needs some love....

So, I want the system to be able to use "open" authentication if the user so wishes, this is for 2 reasons.

1. My keys are all messed up! - Turn on open mode and everything just gets cleaned out
2. I am in a secure environment, just approves everything! - with open mode the keys will just be accepted

Do this via a sys function

The service module needs to manage services for multiple operating systems

Add in a libvirt module

Right now it is only a proof of concept, but it needs the copy logic to work, it needs to copy recursively correctly, and the copy logic needs to mimic cp EXACTLY.
salt-cp needs a lot of work, we might just have the basics done for 0.8.0

Add in a pacman module

So the minion disappears when it is doing a long operation, this is a serious issue

This will almost always need more functionality added, post additions to this ticket

, should be 0400

Modules like pacman should be done away with in favor of general modules, so that a simple "package" module can do package management across multiple distros. I am thinking that we just have a bunch of private methods in the modules and called function maps to the private functions based on facter info.

Create a stats module to gather globs of statistics on the systems

Right now Salt does not ask the master to verify the minion's public keys on the master, the master should have manual signing for minion authentication.

enable looking up old job results