// NewCoreManager creates a new core plugin manager.
func NewCoreManager(instanceIdPtr *string, regionPtr *string, log logger.T) (cm *CoreManager, err error) {
// initialize appconfig
var config appconfig.SsmagentConfig
if config, err = appconfig.Config(false); err != nil {
log.Errorf("Could not load config file: %v", err)
return
}
// initialize region
if *regionPtr != "" {
if err = platform.SetRegion(*regionPtr); err != nil {
log.Errorf("error occured setting the region, %v", err)
return
}
}
var region string
if region, err = platform.Region(); err != nil {
log.Errorf("error fetching the region, %v", err)
return
}
log.Debug("Using region:", region)
// initialize instance ID
if *instanceIdPtr != "" {
if err = platform.SetInstanceID(*instanceIdPtr); err != nil {
log.Errorf("error occured setting the instance ID, %v", err)
return
}
}
var instanceId string
if instanceId, err = platform.InstanceID(); err != nil {
log.Errorf("error fetching the instanceID, %v", err)
return
}
log.Debug("Using instanceID:", instanceId)
if err = fileutil.HardenDataFolder(); err != nil {
log.Errorf("error initializing SSM data folder with hardened ACL, %v", err)
return
}
//Initialize all folders where interim states of executing commands will be stored.
if !initializeBookkeepingLocations(log, instanceId) {
log.Error("unable to initialize. Exiting")
return
}
context := context.Default(log, config).With("[instanceID=" + instanceId + "]")
corePlugins := coreplugins.RegisteredCorePlugins(context)
return &CoreManager{
context: context,
corePlugins: *corePlugins,
}, nil
}
func main() {
defer log.Flush()
commandPtr := flag.String("c", "", "a command")
scriptFilePtr := flag.String("f", "", "a script file")
dirPtr := flag.String("d", "", "working directory")
bucketNamePtr := flag.String("b", "", "bucket name")
keyPrefixPtr := flag.String("k", "", "bucket key prefix")
cancelPtr := flag.Bool("cancel", false, "cancel command on key press")
typePtr := flag.String("type", "", "instance type (windows, ubuntu or aml)")
instanceIDPtr := flag.String("i", "", "instance id")
regionPtr := flag.String("r", "us-east-1", "instance region")
flag.Parse()
var timeout int64 = 10000
timeoutPtr := &timeout
var err error
err = platform.SetRegion(*regionPtr)
if err != nil {
log.Error("please specify the region to use.")
return
}
if *commandPtr == "" && *scriptFilePtr == "" {
fmt.Println("No commands specified (use either -c or -f).")
flag.Usage()
return
}
if *keyPrefixPtr == "" {
keyPrefixPtr = nil
}
if *bucketNamePtr == "" {
bucketNamePtr = nil
if keyPrefixPtr != nil {
defaultBucket := "ec2configservice-ssm-logs"
bucketNamePtr = &defaultBucket
}
}
var cc consoleConfig
err = jsonutil.UnmarshalFile("integration-cli.json", &cc)
if err != nil {
log.Error("error parsing consoleConfig ", err)
return
}
// specific instance is provided use only that
if *instanceIDPtr != "" {
cc.Instances = make(map[string]string)
if *typePtr != "" {
cc.Instances[*instanceIDPtr] = *typePtr
} else {
cc.Instances[*instanceIDPtr] = "aml"
}
} else {
// other wise select or filter from the consoleConfig file list
if *typePtr != "" {
for instanceID, instanceType := range cc.Instances {
if instanceType != *typePtr {
delete(cc.Instances, instanceID)
}
}
if len(cc.Instances) == 0 {
log.Error("no instances of type ", *typePtr)
return
}
}
}
ssmSvc := ssm.NewService()
if ssmSvc == nil {
log.Error("couldn't create ssm service.")
return
}
var instanceIDs []string
// first get windows instances (bug in SSM if first instance is not win)
for instanceID, instanceType := range cc.Instances {
if instanceType == "windows" {
instanceIDs = append(instanceIDs, instanceID)
}
}
// then get rest of the instances
for instanceID, instanceType := range cc.Instances {
if instanceType != "windows" {
instanceIDs = append(instanceIDs, instanceID)
}
}
docName := "AWS-BETA-RunShellScript"
if runtime.GOOS == "windows" {
docName = "AWS-RunPowerShellScript"
}
var commands []string
if *commandPtr != "" {
commands = []string{*commandPtr}
} else {
f, err := os.Open(*scriptFilePtr)
if err != nil {
log.Error(err)
return
}
scanner := bufio.NewScanner(f)
for scanner.Scan() {
commands = append(commands, scanner.Text())
}
}
for i := 0; i < len(commands); i++ {
// escape backslashes
commands[i] = strings.Replace(commands[i], `\`, `\\`, -1)
// escape double quotes
commands[i] = strings.Replace(commands[i], `"`, `\"`, -1)
// escape single quotes
// commands[i] = strings.Replace(commands[i], `'`, `\'`, -1)
}
parameters := map[string][]*string{
"commands": aws.StringSlice(commands),
"workingDirectory": aws.StringSlice([]string{*dirPtr}),
}
log.Infof("Sending command %v", parameters)
cmd, err := ssmSvc.SendCommand(log, docName, instanceIDs, parameters, timeoutPtr, bucketNamePtr, keyPrefixPtr)
if cmd == nil || cmd.Command == nil || cmd.Command.CommandId == nil {
log.Error("command was not created. Aborting!")
return
}
if *cancelPtr {
log.Info("Press any key to cancel command")
var b = make([]byte, 1)
os.Stdin.Read(b)
log.Info("Canceling command ")
ssmSvc.CancelCommand(log, *cmd.Command.CommandId, instanceIDs)
}
log.Info("================== Looping for results ================")
log.Flush()
time.Sleep(1000 * time.Millisecond)
for {
done := true
inst:
for instanceID, instanceType := range cc.Instances {
descr := fmt.Sprintf("%v [%v]", instanceID, instanceType)
out, err := ssmSvc.ListCommandInvocations(log, instanceID, *cmd.Command.CommandId)
if err != nil {
continue
}
for _, inv := range out.CommandInvocations {
if *inv.Status == "Pending" {
log.Infof("Instance %v is in status %v; waiting some more", descr, *inv.Status)
done = false
continue inst
}
data, err := json.Marshal(inv)
if err != nil {
log.Error(err)
continue
}
log.Debug(jsonutil.Indent(string(data)))
for _, cp := range inv.CommandPlugins {
if cp.Output == nil {
log.Errorf("Output Nil for %v", descr)
continue
}
var o interface{}
err := json.Unmarshal([]byte(*cp.Output), &o)
if err != nil {
log.Errorf("error parsing %v\n err=%v", *cp.Output, err)
}
log.Info(descr, " : ", prettyPrint(o, 0))
}
}
}
if done {
break
}
time.Sleep(3000 * time.Millisecond)
}
// c.Wait()*/
}