Performs an svn status command on a working copy
@function status
@memberof commands
@param {string} wc - Working copy target
@param {object} [options] - Options object
@param {function} [callback] - Complete callback
@alias stat
@alias st
518599
function( wc, options, callback ) {
	if ( typeof options === 'function' ) {
		callback = options;
		options = null;
	}
	options = options || {};
	addExtraOptions( [ 'quiet', 'depth' ], options );
	executeSvnXml( [ 'status', wc ], options, callback );
}
1020388
function request(svc, operation, params, next, extra) {
    var world = this;

    if (!svc) svc = this.service;
    if (typeof svc === 'string') svc = this[svc];

    svc[operation](params, function(err, data) {
      world.response = this;
      world.error = err;
      world.data = data;

      try {
        if (typeof next.condition === 'function') {
          var condition = next.condition.call(world, world);
          if (!condition) {
            next.fail(new Error('Request success condition failed'));
            return;
          }
        }

        if (extra) {
          extra.call(world, world.response);
          next.call(world);
        }
        else if (extra !== false && err) {
          world.unexpectedError(world.response, next);
        } else {
          next.call(world);
        }
      } catch (err) {
        next.fail(err);
      }
    });
  }
1252845
function _setStatus(status, closeReason) {
        // Don't send a notification when the status didn't actually change
        if (status === exports.status) {
            return;
        }

        exports.status = status;

        var reason = status === STATUS_INACTIVE ? closeReason : null;
        exports.trigger("statusChange", status, reason);
    }
1113
def after_feature(context, feature):
    
    context.pctl.stop_all()
    shutil.rmtree(os.path.join(context.pctl.patroni_path, 'data'))
    context.dcs_ctl.cleanup_service_tree()
    if feature.status == 'failed':
        shutil.copytree(context.pctl.output_dir, context.pctl.output_dir + '_failed')
228129
public void updateServiceInstanceInternalStatus(String serviceName, String instanceId, OperationalStatus status, final RegistrationCallback cb, Object context){
        ProtocolHeader header = new ProtocolHeader();
        header.setType(ProtocolType.UpdateServiceInstanceInternalStatus);

        UpdateServiceInstanceInternalStatusProtocol protocol = new UpdateServiceInstanceInternalStatusProtocol(serviceName, instanceId, status);

        ProtocolCallback pcb = new ProtocolCallback(){

            @Override
            public void call(boolean result, Response response,
                    ErrorCode error, Object ctx) {
                cb.call(result, error, ctx);
            }

        };

        connection.submitCallbackRequest(header, protocol, pcb, context);
    }
1298687
private String winGetFaxJobStatus(String serverName,int faxJobID)
    {
        String status=null;
        synchronized(WindowsFaxClientSpiHelper.NATIVE_LOCK)
        {
            //pre native call
            this.preNativeCall();
            
            //invoke native
            status=WindowsJNIFaxClientSpi.getFaxJobStatusNative(serverName,faxJobID);
        }
        
        return status;
    }
464700
function gitStatus(file, callback) {
        exec('git status --porcelain ' + file, {}, function (error, stdout, stderr) {
            if (error || stderr) {
                grunt.fatal("Error with git status: " + stderr);
            }
            callback(stdout ? false : true);
        });
    }
369127
public function status($path = null)
    {
        if (null === $this->wc) {
            throw new \RuntimeException('Working copy not initialized, have you tried checkout()?');
        }

        return $this->wc->status($path);
    }
460046
function cbmain (err, state) {
    var localfile = null
    if (err) {
      if (err.usrmsg) {
        print(err.usrmsg)
        return
      }
      else {
        console.log(err.message)
        return
      }
    }
    if (!isEmpty(state.bins)) {
      localfile = path.join(getActiveBin(state.bins), that.flocal)
    }
    writeState(state, localfile, function (err, status) {
      if (err) throw err

    })
  }
632289
function status() {
  var tasks = [],
      cwd = process.cwd();

  findRepos(function(err, repos) {
    if (err) return console.log(err);
    repos.forEach(function(repo) {
      tasks.push(function(done) {
        repo.status(function(err, status) {
          if (err) return done(err);
          if (argv.b) {
            repo.branch(function(err, head) {
              if (err) return done(err);
              done(null, {status: status, head: head});
            });
          }
          else {
            done(null, {status: status});
          }
        });
      });
    });
    async.series(tasks, function(err, results) {
      if (err) return console.log(err);

      var row,
          col,
          res,
          file,
          head = [],
          table,
          symbol;

      head.push('Repo');
      if (argv.b) {
        head.push('Branch');
      }
      head.push('Status');

      table = new Table({
        head: head,
        style: {
          compact: true,
          'padding-left': 1,
          'padding-right': 1,
          head: ['white', 'bold']
        }
      });

      results.forEach(function(res) {
        var row = [];

        row.push(res.status.repo.path.replace(cwd + '/', ''));
        if (argv.b) {
          row.push(res.head.name);
        }
        row.push(res.status.clean ? 'Clean'.green : 'Changed'.red);
        table.push(row);

        if (argv.v) {
          for (var name in res.status.files) {
            row = [];
            row.push('');
            if (argv.b) {
              row.push('');
            }
            switch (res.status.files[name].type) {
              case 'A':
                symbol = '+'.green; break;
              case 'D':
                symbol = '-'.red; break;
              case 'M':
                symbol = '*'.yellow; break;
              default:
                symbol = '~'.grey; break;
            }
            row.push(' ' + symbol + ' ' + name);
            table.push(row);
          }
        }
      });

      console.log(table.toString());
    });
  });
}
7975
function copy(source, destination, callback) {
  cp(source, destination, {overwrite: true}, function done(err) {
    if (err) callback(err)
    else callback()
  })
}
965403
def status(name, sig=None):
    '''
    
    '''
    cmd = 's6-svstat {0}'.format(_service_path(name))
    out = __salt__['cmd.run_stdout'](cmd)
    try:
        pid = re.search(r'up \(pid (\d+)\)', out).group(1)
    except AttributeError:
        pid = ''
    return pid
235598
function(callback) {
				async.each(task.files, function(file, callback2) {
					var srcPath = file.src[0],
						extName = path.extname(srcPath).toLowerCase();

					// if it’s an SVG or a PDF, copy the file to the output dir
					if (extName === '.svg' || extName === '.pdf') {
						var dstPath = getDestination(srcPath, file.dest, false, options);
						fs.copy(srcPath, dstPath, function(err){
							if (err) {
								grunt.fail.fatal(err);
							}

							outputFiles.push(dstPath);
							callback2(null);
						});
					} else {
						callback2(null);
					}

				}, callback);
			}
21826
function reportStatus(status, outputFile) {
  let log = [''];
  log.push('Suites passed:');
  status.passed.forEach(function (val) {
    log.push('  ' + val);
  });

  if (status.failed.length == 0) {
    log.push('All tests passed');
  } else {
    log.push('Suites failed:');
    status.failed.forEach(function (val) {
      log.push('  ' + val);
    });
  }
  log.push('\nElapsed time: ' + status.elapsedTime + ' seconds');
  log = log.join('\n');
  console.log(log);
  fs.appendFileSync(outputFile, log);
}
598632
function CopyKeyJob(options, context, taskId) {
        CopyKeyJob.super_.call(this, logger, options, context, taskId);
        assert.string(this.context.target);
        this.nodeId = this.context.target;
        this.commandUtil = new CommandUtil(this.nodeId);
    }
824769
def command_status(prog_name, prof_mgr, prof_name, prog_args):

	
	
	# Retrieve arguments
	parser = argparse.ArgumentParser(
		prog=prog_name
	)
	parser.add_argument(
		"-t",
		"--type",
		required=False,
		action="store_true",
		default=False,
		dest="show_type",
		help="show component qualified class name"
	)
	parser.add_argument(
		"-d",
		"--depth",
		metavar="tree_depth",
		required=False,
		type=argparse_status_depth,
		default=None,
		dest="tree_depth",
		help="integer value of dependency tree depth"
	)
	parser.add_argument(
		"components",
		metavar="comps",
		nargs=argparse.REMAINDER,
		help="system components"
	)
	args = parser.parse_args(prog_args)
	
	# Profile load
	prof_stub = prof_mgr.load(prof_name)
	
	# Collect component stubs
	comp_stubs = []
	if len(args.components) == 0:
		raise Exception("Empty component list")
	for comp_name in args.components:
		comp_stub = prof_stub.component(comp_name)
		component_exists(prof_stub, comp_stub)
		comp_stubs.append(comp_stub)
		
	# Print status
	show_type = args.show_type
	tree_depth = args.tree_depth
	context = prof_stub.context()
	out = io.StringIO()
	for i, comp_stub in enumerate(comp_stubs):
		last = i == len(comp_stubs) - 1
		print_component_status(out, context, comp_stub, last, 1, [], show_type,
				tree_depth)
	out.seek(0)
	sys.stdout.write(out.read())
1333602
function (source, target, callback) {
    source = fss.slashify(source);
    target = fss.slashify(target);

    if (!shell.which('rsync')) {
        log('sync error', 'no rsync command found');
        callback();
    } else {
        log('rsync', fss.baseRelative(source));
        log('remote', target);
        var cmd = [config.rsync, source, target].join(' ');
        var opt = { maxBuffer: 5000*1024 };
        exec(cmd, opt, rsync_end(callback));
    }
}