├── .docs
    ├── .themes
    │   └── yeti
    │   │   ├── base.html
    │   │   ├── content.html
    │   │   ├── css
    │   │       ├── base.css
    │   │       ├── bootstrap-custom.min.css
    │   │       ├── emccode-font.css
    │   │       ├── font-awesome-4.0.3.css
    │   │       ├── hX.css
    │   │       └── highlight.css
    │   │   ├── fonts
    │   │       ├── emccode.eot
    │   │       ├── emccode.svg
    │   │       ├── emccode.ttf
    │   │       ├── emccode.woff
    │   │       ├── fontawesome-webfont.eot
    │   │       ├── fontawesome-webfont.svg
    │   │       ├── fontawesome-webfont.ttf
    │   │       └── fontawesome-webfont.woff
    │   │   ├── img
    │   │       ├── emccode-logo-48x48.png
    │   │       ├── emccode-logo-mono-48x48.png
    │   │       └── favicon.ico
    │   │   ├── js
    │   │       ├── base.js
    │   │       ├── bootstrap-3.0.3.min.js
    │   │       ├── highlight.pack.js
    │   │       └── jquery-1.10.2.min.js
    │   │   ├── nav.html
    │   │   └── toc.html
    ├── about
    │   ├── contributing.md
    │   ├── license.md
    │   └── release-notes.md
    ├── developer-guide
    │   ├── build-reference.md
    │   ├── project-guidelines.md
    │   ├── release-process.md
    │   └── restapi.md
    ├── images
    │   ├── logo.png
    │   ├── marathon.png
    │   └── status.png
    ├── index.md
    └── user-guide
    │   ├── Framework_Testing_Cluster_RHEL7.json
    │   ├── Framework_Testing_Cluster_Ubuntu14.json
    │   ├── configuration.md
    │   ├── demo.md
    │   ├── deployment-strategies.md
    │   ├── experimental.md
    │   ├── h15148-emc-scaleio-deployment-guide.pdf
    │   ├── installation.md
    │   ├── scaleio.json
    │   ├── sioframework-latest.json
    │   ├── sioframework-v020.json
    │   └── troubleshooting.md
├── .gitignore
├── LICENSE
├── README.md
├── VERSION
├── img
    ├── icon-large.png
    ├── icon-medium.png
    ├── icon-small.png
    ├── logo.png
    └── logo.psd
├── mkdocs.yml
├── scaleio-executor
    ├── build.sh
    ├── client
    │   └── http.go
    ├── config
    │   ├── config.go
    │   └── env.go
    ├── executor
    │   ├── common
    │   │   ├── common.go
    │   │   ├── iscaleionode.go
    │   │   ├── scaleionode.go
    │   │   └── waitstates.go
    │   ├── executor.go
    │   ├── pkgmgr
    │   │   ├── deb
    │   │   │   └── ubuntu14
    │   │   │   │   ├── common.go
    │   │   │   │   ├── mdmdebmgr.go
    │   │   │   │   └── nodedebmgr.go
    │   │   ├── mgr
    │   │   │   ├── imdmmgr.go
    │   │   │   ├── inodemgr.go
    │   │   │   ├── isolatorProcedural.go
    │   │   │   ├── mdmmgr.go
    │   │   │   ├── nodemgr.go
    │   │   │   ├── rexrayProcedural.go
    │   │   │   └── scaleioProcedural.go
    │   │   └── rpm
    │   │   │   └── rhel7
    │   │   │       ├── common.go
    │   │   │       ├── mdmrpmmgr.go
    │   │   │       └── noderpmmgr.go
    │   ├── runnode.go
    │   └── scaleionodes
    │   │   ├── dataNode.go
    │   │   ├── primaryMdm.go
    │   │   ├── secondaryMdm.go
    │   │   └── tieBreaker.go
    ├── glide.yaml
    ├── glide.yaml.dev
    ├── main.go
    ├── mesos
    │   ├── exec
    │   │   ├── executor.pb.go
    │   │   └── executor.proto
    │   └── v1
    │   │   ├── mesos.pb.go
    │   │   └── mesos.proto
    ├── protoc.sh
    └── switch.sh
├── scaleio-scheduler
    ├── build.sh
    ├── client
    │   └── http.go
    ├── config
    │   ├── config.go
    │   └── env.go
    ├── glide.yaml
    ├── glide.yaml.dev
    ├── main.go
    ├── mesos
    │   ├── sched
    │   │   ├── scheduler.pb.go
    │   │   └── scheduler.proto
    │   └── v1
    │   │   ├── mesos.pb.go
    │   │   └── mesos.proto
    ├── protoc.sh
    ├── scheduler
    │   ├── common
    │   │   ├── common.go
    │   │   └── waitstates.go
    │   ├── eventhandler.go
    │   ├── kvstore
    │   │   └── kvstore.go
    │   ├── mesos.go
    │   ├── scaleio.go
    │   ├── scheduler.go
    │   ├── selection.go
    │   └── server
    │   │   ├── aws.go
    │   │   ├── executor.go
    │   │   ├── node.go
    │   │   ├── server.go
    │   │   ├── server_test.go
    │   │   ├── state.go
    │   │   ├── statechanges.go
    │   │   └── version.go
    ├── switch.sh
    └── types
    │   └── types.go
└── version.sh


/.docs/.themes/yeti/base.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 |     <head>
 4 |         <meta charset="utf-8">
 5 |         <meta http-equiv="X-UA-Compatible" content="IE=edge">
 6 |         <meta name="viewport" content="width=device-width, initial-scale=1.0">
 7 |         {% if page_description %}<meta name="description" content="{{ page_description }}">{% endif %}
 8 |         {% if site_author %}<meta name="author" content="{{ site_author }}">{% endif %}
 9 |         {% if canonical_url %}<link rel="canonical" href="{{ canonical_url }}">{% endif %}
10 |         {% if favicon %}<link rel="shortcut icon" href="{{ favicon }}">
11 |         {% else %}<link rel="shortcut icon" href="{{ base_url }}/img/favicon.ico">{% endif %}
12 | 
13 | 	<title>{% if page_title %}{{ page_title }} - {% endif %}{{ site_name }}</title>
14 | 
15 |         <link href="{{ base_url }}/css/bootstrap-custom.min.css" rel="stylesheet">
16 |         <link href="{{ base_url }}/css/font-awesome-4.0.3.css" rel="stylesheet">
17 |         <link rel="stylesheet" href="{{ base_url }}/css/highlight.css">
18 |         <link href="{{ base_url }}/css/emccode-font.css" rel="stylesheet">
19 |         <link href="{{ base_url }}/css/base.css" rel="stylesheet">
20 |         {%- for path in extra_css %}
21 |         <link href="{{ path }}" rel="stylesheet">
22 |         {%- endfor %}
23 | 
24 |         <!-- HTML5 shim and Respond.js IE8 support of HTML5 elements and media queries -->
25 |         <!--[if lt IE 9]>
26 |             <script src="https://oss.maxcdn.com/libs/html5shiv/3.7.0/html5shiv.js"></script>
27 |             <script src="https://oss.maxcdn.com/libs/respond.js/1.3.0/respond.min.js"></script>
28 |         <![endif]-->
29 | 
30 |         {% if google_analytics %}
31 |         <script>
32 |             (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
33 |             (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
34 |             m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
35 |             })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
36 | 
37 |             ga('create', '{{ google_analytics[0] }}', '{{ google_analytics[1] }}');
38 |             ga('send', 'pageview');
39 |         </script>
40 |         {% endif %}
41 |     </head>
42 | 
43 |     <body>
44 | 
45 |         {% include "nav.html" %}
46 |         <div class="container {% if not page_title %}index{% endif %}">
47 |             <div class="col-md-3">{% include "toc.html" %}</div>
48 |             <div class="col-md-9" role="main">{% include "content.html" %}</div>
49 |         </div>
50 | 
51 |         <script src="{{ base_url }}/js/jquery-1.10.2.min.js"></script>
52 |         <script src="{{ base_url }}/js/bootstrap-3.0.3.min.js"></script>
53 |         <script src="{{ base_url }}/js/highlight.pack.js"></script>
54 |         <script src="{{ base_url }}/js/base.js"></script>
55 |         {%- for path in extra_javascript %}
56 |         <script src="{{ path }}"></script>
57 |         {%- endfor %}
58 |     </body>
59 | </html>
60 | 


--------------------------------------------------------------------------------
/.docs/.themes/yeti/content.html:
--------------------------------------------------------------------------------
 1 | {% if meta %}
 2 | {% if meta.source %}
 3 | <div class="source-links">
 4 | {% for filename in meta.source %}
 5 |     <span class="label label-primary">{{ filename }}</span>
 6 | {% endfor %}
 7 | </div>
 8 | {% endif %}
 9 | {% endif %}
10 | 
11 | {{ content }}
12 | 


--------------------------------------------------------------------------------
/.docs/.themes/yeti/css/base.css:
--------------------------------------------------------------------------------
  1 | /* hide the RTD footer */
  2 | div.injected {
  3 |     display: none !important;
  4 | }
  5 | 
  6 | li.divider {
  7 |     background-color: rgba(255, 255, 255, 0.1) !important;
  8 | }
  9 | 
 10 | h1#rex-ray::before {
 11 |     content: "r";
 12 |     display: block;
 13 |     font-family: "emccode" !important;
 14 |     height: 100px;
 15 |     font-size: 100px;
 16 |     margin-top: -25px;
 17 |     text-shadow: 2px 2px 3px rgba(0, 0, 0, .25);
 18 | }
 19 | 
 20 | @media (max-width: 768px) {
 21 |     h1#rex-ray::before {
 22 |         padding-top: 10px;
 23 |     }
 24 | }
 25 | 
 26 | div.col-md-9 h1:first-of-type {
 27 |     text-align: center;
 28 |     font-size: 60px;
 29 |     font-weight: 300;
 30 |     text-shadow: 2px 2px 3px rgba(0, 0, 0, .25);
 31 | }
 32 | 
 33 | div.col-md-9 > p:first-of-type {
 34 |     text-align: center;
 35 |     text-shadow: 2px 2px 3px rgba(0, 0, 0, .15);
 36 | }
 37 | 
 38 | div.col-md-9 p.admonition-title:first-of-type {
 39 |     text-align: left;
 40 | }
 41 | 
 42 | div.col-md-9 h1:first-of-type .headerlink {
 43 |     display: none;
 44 | }
 45 | 
 46 | body {
 47 |     padding-top: 70px;
 48 | }
 49 | 
 50 | h1[id]:before, h2[id]:before, h3[id]:before, h4[id]:before, h5[id]:before, h6[id]:before {
 51 |     content: "";
 52 |     display: block;
 53 |     margin-top: -75px;
 54 |     height: 75px;
 55 | }
 56 | 
 57 | ul.nav li.main {
 58 |     font-weight: bold;
 59 | }
 60 | 
 61 | div.col-md-3 {
 62 |     padding-left: 0;
 63 | }
 64 | 
 65 | div.col-md-9 {
 66 |     padding-bottom: 100px;
 67 | }
 68 | 
 69 | div.source-links {
 70 |     float: right;
 71 | }
 72 | 
 73 | /*
 74 |  * Side navigation
 75 |  *
 76 |  * Scrollspy and affixed enhanced navigation to highlight sections and secondary
 77 |  * sections of docs content.
 78 |  */
 79 | 
 80 | /* By default it's not affixed in mobile views, so undo that */
 81 | .bs-sidebar.affix {
 82 |     position: static;
 83 | }
 84 | 
 85 | .bs-sidebar.well {
 86 |     padding: 0;
 87 | }
 88 | 
 89 | /* First level of nav */
 90 | .bs-sidenav {
 91 |     margin-top: 30px;
 92 |     margin-bottom: 30px;
 93 |     padding-top:    10px;
 94 |     padding-bottom: 10px;
 95 |     border-radius: 5px;
 96 | }
 97 | 
 98 | /* All levels of nav */
 99 | .bs-sidebar .nav > li > a {
100 |     display: block;
101 |     padding: 5px 20px;
102 |     z-index: 1;
103 | }
104 | .bs-sidebar .nav > li > a:hover,
105 | .bs-sidebar .nav > li > a:focus {
106 |     text-decoration: none;
107 |     border-right: 1px solid;
108 | }
109 | .bs-sidebar .nav > .active > a,
110 | .bs-sidebar .nav > .active:hover > a,
111 | .bs-sidebar .nav > .active:focus > a {
112 |     font-weight: bold;
113 |     background-color: transparent;
114 |     border-right: 1px solid;
115 | }
116 | 
117 | /* Nav: second level (shown on .active) */
118 | .bs-sidebar .nav .nav {
119 |     display: none; /* Hide by default, but at >768px, show it */
120 |     margin-bottom: 8px;
121 | }
122 | .bs-sidebar .nav .nav > li > a {
123 |     padding-top:    3px;
124 |     padding-bottom: 3px;
125 |     padding-left: 30px;
126 |     font-size: 90%;
127 | }
128 | 
129 | .bs-sidebar .nav .nav .nav > li > a {
130 |     font-size: 80%;
131 |     padding-left: 40px;
132 | }
133 | 
134 | /* Show and affix the side nav when space allows it */
135 | @media (min-width: 992px) {
136 |     .bs-sidebar .nav > .active > ul {
137 |         display: block;
138 |     }
139 |     /* Widen the fixed sidebar */
140 |     .bs-sidebar.affix,
141 |     .bs-sidebar.affix-bottom {
142 |         width: 213px;
143 |     }
144 |     .bs-sidebar.affix {
145 |         position: fixed; /* Undo the static from mobile first approach */
146 |         top: 80px;
147 |     }
148 |     .bs-sidebar.affix-bottom {
149 |         position: absolute; /* Undo the static from mobile first approach */
150 |     }
151 |     .bs-sidebar.affix-bottom .bs-sidenav,
152 |     .bs-sidebar.affix .bs-sidenav {
153 |         margin-top: 0;
154 |         margin-bottom: 0;
155 |     }
156 | }
157 | @media (min-width: 1200px) {
158 |     /* Widen the fixed sidebar again */
159 |     .bs-sidebar.affix-bottom,
160 |     .bs-sidebar.affix {
161 |         width: 263px;
162 |     }
163 | }
164 | 


--------------------------------------------------------------------------------
/.docs/.themes/yeti/css/emccode-font.css:
--------------------------------------------------------------------------------
 1 | @charset "UTF-8";
 2 | 
 3 | @font-face {
 4 |     font-family: "emccode";
 5 |     src:url("../fonts/emccode.eot");
 6 |     src:url("../fonts/emccode.eot?#iefix") format("embedded-opentype"),
 7 |         url("../fonts/emccode.woff") format("woff"),
 8 |         url("../fonts/emccode.ttf") format("truetype"),
 9 |         url("../fonts/emccode.svg#emccode") format("svg");
10 |     font-weight: normal;
11 |     font-style: normal;
12 | }
13 | 
14 | [data-icon]:before {
15 |     font-family: "emccode" !important;
16 | }
17 | 
18 | [class^="icon-"]:before,
19 | [class*=" icon-"]:before {
20 |     font-family: "emccode" !important;
21 | }
22 | 
23 | .icon-emccode-logo:before {
24 |     content: "e";
25 |     vertical-align: middle;
26 | }
27 | 
28 | .icon-emccode-logo:after {
29 |     content: " EMC{code}";
30 | }
31 | 
32 | .icon-rexray-logo:before {
33 |     content: "r";
34 |     vertical-align: middle;
35 | }
36 | 


--------------------------------------------------------------------------------
/.docs/.themes/yeti/css/hX.css:
--------------------------------------------------------------------------------
 1 | h2 {
 2 |     padding-top: 55px;
 3 |     margin-top: -40px;
 4 | }
 5 | 
 6 | h2:not(:first-of-type)::after {
 7 |     content: " ";
 8 |     display: block;
 9 |     border-bottom: 1px solid rgba(0, 0, 0, 0.1);
10 | }
11 | 
12 | h3 {
13 |     padding-top: 50px;
14 |     margin-top: -40px;
15 | }
16 | h3::after{
17 |     content: " ";
18 |     display: block;
19 |     border-bottom: 1px solid rgba(0, 0, 0, 0.1);
20 | }
21 | 
22 | h4 {
23 |     padding-top: 45px;
24 |     margin-top: -40px;
25 | }
26 | h4::after {
27 |     content: " ";
28 |     display: block;
29 |     border-bottom: 1px solid rgba(0, 0, 0, 0.1);
30 | }
31 | 


--------------------------------------------------------------------------------
/.docs/.themes/yeti/css/highlight.css:
--------------------------------------------------------------------------------
  1 | /*
  2 | This is the GitHub theme for highlight.js
  3 | 
  4 | github.com style (c) Vasily Polovnyov <vast@whiteants.net>
  5 | 
  6 | */
  7 | 
  8 | .hljs {
  9 |   display: block;
 10 |   overflow-x: auto;
 11 |   padding: 0.5em;
 12 |   color: #333;
 13 |   -webkit-text-size-adjust: none;
 14 | }
 15 | 
 16 | .hljs-comment,
 17 | .diff .hljs-header,
 18 | .hljs-javadoc {
 19 |   color: #998;
 20 |   font-style: italic;
 21 | }
 22 | 
 23 | .hljs-keyword,
 24 | .css .rule .hljs-keyword,
 25 | .hljs-winutils,
 26 | .nginx .hljs-title,
 27 | .hljs-subst,
 28 | .hljs-request,
 29 | .hljs-status {
 30 |   color: #333;
 31 |   font-weight: bold;
 32 | }
 33 | 
 34 | .hljs-number,
 35 | .hljs-hexcolor,
 36 | .ruby .hljs-constant {
 37 |   color: #008080;
 38 | }
 39 | 
 40 | .hljs-string,
 41 | .hljs-tag .hljs-value,
 42 | .hljs-phpdoc,
 43 | .hljs-dartdoc,
 44 | .tex .hljs-formula {
 45 |   color: #d14;
 46 | }
 47 | 
 48 | .hljs-title,
 49 | .hljs-id,
 50 | .scss .hljs-preprocessor {
 51 |   color: #900;
 52 |   font-weight: bold;
 53 | }
 54 | 
 55 | .hljs-list .hljs-keyword,
 56 | .hljs-subst {
 57 |   font-weight: normal;
 58 | }
 59 | 
 60 | .hljs-class .hljs-title,
 61 | .hljs-type,
 62 | .vhdl .hljs-literal,
 63 | .tex .hljs-command {
 64 |   color: #458;
 65 |   font-weight: bold;
 66 | }
 67 | 
 68 | .hljs-tag,
 69 | .hljs-tag .hljs-title,
 70 | .hljs-rule .hljs-property,
 71 | .django .hljs-tag .hljs-keyword {
 72 |   color: #000080;
 73 |   font-weight: normal;
 74 | }
 75 | 
 76 | .hljs-attribute,
 77 | .hljs-variable,
 78 | .lisp .hljs-body,
 79 | .hljs-name {
 80 |   color: #008080;
 81 | }
 82 | 
 83 | .hljs-regexp {
 84 |   color: #009926;
 85 | }
 86 | 
 87 | .hljs-symbol,
 88 | .ruby .hljs-symbol .hljs-string,
 89 | .lisp .hljs-keyword,
 90 | .clojure .hljs-keyword,
 91 | .scheme .hljs-keyword,
 92 | .tex .hljs-special,
 93 | .hljs-prompt {
 94 |   color: #990073;
 95 | }
 96 | 
 97 | .hljs-built_in {
 98 |   color: #0086b3;
 99 | }
100 | 
101 | .hljs-preprocessor,
102 | .hljs-pragma,
103 | .hljs-pi,
104 | .hljs-doctype,
105 | .hljs-shebang,
106 | .hljs-cdata {
107 |   color: #999;
108 |   font-weight: bold;
109 | }
110 | 
111 | .hljs-deletion {
112 |   background: #fdd;
113 | }
114 | 
115 | .hljs-addition {
116 |   background: #dfd;
117 | }
118 | 
119 | .diff .hljs-change {
120 |   background: #0086b3;
121 | }
122 | 
123 | .hljs-chunk {
124 |   color: #aaa;
125 | }
126 | 


--------------------------------------------------------------------------------
/.docs/.themes/yeti/fonts/emccode.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thecodeteam/scaleio-framework/3fb79e9a2a1a130ca0fd201678a9fbaf92243d0e/.docs/.themes/yeti/fonts/emccode.eot


--------------------------------------------------------------------------------
/.docs/.themes/yeti/fonts/emccode.svg:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" standalone="no"?>
 2 | <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
 3 | <svg xmlns="http://www.w3.org/2000/svg">
 4 | <metadata>Generated by Fontastic.me</metadata>
 5 | <defs>
 6 | <font id="emccode" horiz-adv-x="512">
 7 | <font-face font-family="emccode" units-per-em="512" ascent="480" descent="-32"/>
 8 | <missing-glyph horiz-adv-x="512" />
 9 | 
10 | <glyph glyph-name="emccode-logo" unicode="&#101;" d="M97 468c-3-3-7-7-8-8-11-10-26-28-37-44-32-48-50-105-50-164 0-73 26-140 75-195 11-13 16-17 22-18 11-3 22 4 25 15 1 3 1 9 0 12-1 4-3 6-9 12-11 12-20 23-28 36-7 10-10 16-16 27-14 28-21 55-25 87-1 9-1 32 0 40 2 29 8 55 18 80 4 8 11 23 15 30 8 15 23 35 25 35 1 0 5-4 14-13 8-7 13-13 13-13 0 0-1-3-3-6-9-12-16-23-23-36-9-19-16-40-19-61-2-12-2-17-2-32 0-14 0-20 2-32 5-30 16-59 33-85 8-12 15-21 25-31 35-36 80-58 129-63 8-1 23-2 27-1 8 1 14 6 17 14 4 11-3 24-15 27-1 1-4 1-6 1-9 0-22 2-31 3-27 6-53 17-75 35-7 5-20 19-26 26-5 6-12 17-16 23-28 51-29 112-1 163 5 10 14 23 15 23 1 1 3-2 13-11 9-9 12-13 12-13 0-1-1-3-2-4-8-13-15-27-18-41-3-11-4-18-4-30-2-59 36-113 93-131 27-9 57-9 83 0 32 11 59 33 75 63 4 6 7 14 7 15l0 2-22 0c-13 0-23 0-24 0 0-1-1-2-3-4-8-13-21-24-35-31-25-12-55-12-80 0-46 22-65 77-42 122 11 24 33 42 58 49 10 2 18 3 29 2 19 0 38-8 53-20 5-5 12-12 16-17 1-3 3-5 4-6 0 0 2 0 23 0 26 0 24-1 23 4-2 3-7 13-9 17-22 36-59 60-101 65-8 0-21 0-28 0-22-3-41-10-59-21-3-2-5-3-6-3 0 0-26 25-57 56-35 35-56 56-57 56 0 0-3-2-7-6z m184-3c-32-3-64-13-92-29-6-3-16-10-17-11 0 0 0-1 0-2 0 0 7-7 14-15 11-10 15-14 16-14 0 0 2 1 4 2 17 11 37 19 57 23 13 3 19 3 34 3 14 0 20-1 31-3 59-11 108-52 128-108 5-12 10-35 9-37-1 0-9 0-59 0-38 0-58 0-59 0 0 0-1 2-2 4-8 15-22 25-38 28-5 1-15 1-20 0-10-2-20-7-28-14-8-8-13-18-16-29-1-5-1-17 0-21 2-10 8-20 14-28 6-5 14-11 22-13 6-2 10-3 18-3 7 0 8 0 12 1 16 4 28 13 36 28 1 2 2 4 2 4 1 0 37 0 81 0 72 0 81 0 81 1 1 1 1 32 0 40-3 28-10 51-21 75-17 34-42 61-73 82-31 21-66 33-104 36-7 0-23 0-30 0z"/>
11 | <glyph glyph-name="rexray-logo" unicode="&#114;" d="M124 358c-10-4-18-9-18-11 0-3-6-15-13-29-7-13-13-26-13-28 0-6 36 1 51 9 18 11 24 22 25 42 0 27-1 28-32 17z m-46-93c4 0 10-1 18-3 6-2 15-4 20-5 11-2 11-8 1-21-7-7-11-10-20-10-12 0-26 12-27 21 0 3-1 7-1 9-1 6 2 9 9 9z m137 21c5-1 10-5 10-9 0-8-8-16-14-13-5 1-6 4-4 10 1 5 4 10 6 11 1 0 2 1 2 1z m16 79c4 0 11-3 16-8 7-7 7-15 0-15-4 0-19 16-19 20 0 2 1 3 3 3z m-19 93c-3 0-2-2 2-7 8-8 10-19 4-19-3 1-8 2-13 5-8 5-32 6-36 3-1-1-1-4 2-7 5-6-1-11-16-16-8-2-10-3-6-4 17-1 18-14 1-18l-9-2 11-13c6-6 12-14 12-17 0-2 1-6 1-8 1-2 1-4 2-6 0-2 3-4 6-4 11 0 11-5 0-11-5-2-9-7-9-9 0-2-4-10-8-16-7-9-7-11-3-14 7-4 3-21-5-20-3 1-5 4-5 10 0 5 0 9-1 9-1 0-38-16-43-19-4-2-16-2-34 0-27 4-29 3-40-4-8-4-13-9-13-13 0-3-1-10-4-15-3-5-5-14-7-21-2-11-1-12 4-11 7 1 7 2 2-45-2-26 0-31 8-23 6 7 8 1 5-13-3-7-4-14-4-16 0-4 14-1 26 6 12 7 17 1 10-15l-4-10 10 0c6 0 13 1 15 3 5 6 10 0 10-13l0-12 14 1c14 2 28 9 32 16 6 9 12 5 12-8 0-24 4-27 24-16 14 7 18 6 18-6 0-7 1-8 11-6 5 1 13 6 18 11 7 9 10 9 35 10 15 1 38 2 50 4 13 2 51 4 87 5 21 14 22 18-3 42-8 8-15 17-15 19 0 2-2 5-5 7-2 3-4 8-4 12 0 6-2 7-9 7-7-1-10 1-13 7-5 11-5 37 1 48 4 8 4 10 0 11-8 3-6 10 7 25 7 8 15 18 18 23 6 10 11 12 14 4 1-3-3-10-10-18-10-10-11-13-8-18 3-5 2-8-5-18-9-13-10-20-6-42 1-9 3-11 6-8 6 5 14 1 14-7 0-9 16-40 24-48 7-7 7-7 18 18 7 16 13 24 17 24 6 0 8-3 9-14 1-11 3-11 12 0 11 15 17 29 17 40 0 9 1 10 7 8 8-1 8 0 12 22 2 15 8 32 18 51 18 36 18 41-3 46-9 2-23 7-31 10-8 4-19 8-25 8-10 1-13-1-19-10-4-6-8-16-8-22 0-12-5-16-11-10-5 5-4 7 3 27 5 12 13 26 18 31l8 9-7 2c-9 2-10 12-1 17 3 2 7 6 8 9 1 4 0 5-8 3-6-1-15-4-20-7-17-8-19-7-17 11 2 15 2 18-5 24-9 10-13 11-13 1 0-4-1-9-3-11-6-5-19-5-19 0 0 9-14 22-33 31-27 13-33 13-28 2 6-11-1-16-12-9-7 4-52 17-62 17z"/>
12 | </font></defs></svg>
13 | 


--------------------------------------------------------------------------------
/.docs/.themes/yeti/fonts/emccode.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thecodeteam/scaleio-framework/3fb79e9a2a1a130ca0fd201678a9fbaf92243d0e/.docs/.themes/yeti/fonts/emccode.ttf


--------------------------------------------------------------------------------
/.docs/.themes/yeti/fonts/emccode.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thecodeteam/scaleio-framework/3fb79e9a2a1a130ca0fd201678a9fbaf92243d0e/.docs/.themes/yeti/fonts/emccode.woff


--------------------------------------------------------------------------------
/.docs/.themes/yeti/fonts/fontawesome-webfont.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thecodeteam/scaleio-framework/3fb79e9a2a1a130ca0fd201678a9fbaf92243d0e/.docs/.themes/yeti/fonts/fontawesome-webfont.eot


--------------------------------------------------------------------------------
/.docs/.themes/yeti/fonts/fontawesome-webfont.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thecodeteam/scaleio-framework/3fb79e9a2a1a130ca0fd201678a9fbaf92243d0e/.docs/.themes/yeti/fonts/fontawesome-webfont.ttf


--------------------------------------------------------------------------------
/.docs/.themes/yeti/fonts/fontawesome-webfont.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thecodeteam/scaleio-framework/3fb79e9a2a1a130ca0fd201678a9fbaf92243d0e/.docs/.themes/yeti/fonts/fontawesome-webfont.woff


--------------------------------------------------------------------------------
/.docs/.themes/yeti/img/emccode-logo-48x48.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thecodeteam/scaleio-framework/3fb79e9a2a1a130ca0fd201678a9fbaf92243d0e/.docs/.themes/yeti/img/emccode-logo-48x48.png


--------------------------------------------------------------------------------
/.docs/.themes/yeti/img/emccode-logo-mono-48x48.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thecodeteam/scaleio-framework/3fb79e9a2a1a130ca0fd201678a9fbaf92243d0e/.docs/.themes/yeti/img/emccode-logo-mono-48x48.png


--------------------------------------------------------------------------------
/.docs/.themes/yeti/img/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thecodeteam/scaleio-framework/3fb79e9a2a1a130ca0fd201678a9fbaf92243d0e/.docs/.themes/yeti/img/favicon.ico


--------------------------------------------------------------------------------
/.docs/.themes/yeti/js/base.js:
--------------------------------------------------------------------------------
 1 | 
 2 | /* Highlight */
 3 | $( document ).ready(function() {
 4 |     hljs.initHighlightingOnLoad();
 5 |     $('table').addClass('table table-striped table-hover');
 6 | });
 7 | 
 8 | 
 9 | $('body').scrollspy({
10 |     target: '.bs-sidebar',
11 | });
12 | 
13 | 
14 | /* Prevent disabled links from causing a page reload */
15 | $("li.disabled a").click(function() {
16 |     event.preventDefault();
17 | });
18 | 
19 | var mkdocs_page_name = "";
20 | 


--------------------------------------------------------------------------------
/.docs/.themes/yeti/nav.html:
--------------------------------------------------------------------------------
 1 | <div class="navbar navbar-default navbar-fixed-top" role="navigation">
 2 |     <div class="container">
 3 | 
 4 |         <!-- Collapsed navigation -->
 5 |         <div class="navbar-header">
 6 |             <!-- Expander button -->
 7 |             <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
 8 |                 <span class="sr-only">Toggle navigation</span>
 9 |                 <span class="icon-bar"></span>
10 |                 <span class="icon-bar"></span>
11 |                 <span class="icon-bar"></span>
12 |             </button>
13 | 
14 |             <!-- Main title -->
15 |             <a class="navbar-brand" href="{{ homepage_url }}">
16 |                 {{ site_name }}
17 |             </a>
18 |         </div>
19 | 
20 |         <!-- Expanded navigation -->
21 |         <div class="navbar-collapse collapse">
22 |             <!-- Main navigation -->
23 |             <ul class="nav navbar-nav">
24 |             {% for nav_item in nav %}
25 |             {% if nav_item.children %}
26 |                 <li class="dropdown{% if nav_item.active %} active{% endif %}">
27 |                     <a href="#" class="dropdown-toggle" data-toggle="dropdown">{{ nav_item.title }} <b class="caret"></b></a>
28 |                     <ul class="dropdown-menu">
29 |                     {% for nav_item in nav_item.children %}
30 |                         {% if nav_item.title == "Amazon EC2" or
31 |                               nav_item.title == "Docker" %}
32 |                         <li role="separator" class="divider"></li>
33 |                         {% endif %}
34 |                         <li {% if nav_item.active %}class="active"{% endif %}>
35 |                             <a href="{{ nav_item.url }}">{{ nav_item.title }}</a>
36 |                         </li>
37 |                     {% endfor %}
38 |                     </ul>
39 |                 </li>
40 |             {% else %}
41 |                 <li {% if nav_item.active %}class="active"{% endif %}>
42 |                     <a href="{{ nav_item.url }}">{{ nav_item.title }}</a>
43 |                 </li>
44 |             {% endif %}
45 |             {% endfor %}
46 |             </ul>
47 | 
48 |             <!-- Search, Navigation and Repo links -->
49 |             <ul class="nav navbar-nav navbar-right">
50 |                 <li {% if not previous_page %}class="disabled"{% endif %}>
51 |                     <a rel="next" {% if previous_page %}href="{{ previous_page.url }}"{% endif %}>
52 |                         <i class="fa fa-arrow-left"></i> Previous
53 |                     </a>
54 |                 </li>
55 |                 <li {% if not next_page %}class="disabled"{% endif %}>
56 |                     <a rel="prev" {% if next_page %}href="{{ next_page.url }}"{% endif %}>
57 |                         Next <i class="fa fa-arrow-right"></i>
58 |                     </a>
59 |                 </li>
60 |                 {% if repo_url %}
61 |                 <li>
62 |                     <a href="{{ repo_url }}">
63 |                         {% if repo_name == 'GitHub' %}
64 |                             <i class="fa fa-github"></i>
65 |                         {% elif repo_name == 'Bitbucket' %}
66 |                             <i class="fa fa-bitbucket"></i>
67 |                         {% endif %}
68 |                         {{ repo_name }}
69 |                     </a>
70 |                 </li>
71 |                 {% endif %}
72 |                 <li>
73 |                     <a href="https://emccode.github.io">
74 |                         <i class="fa icon-emccode-logo"></i>
75 |                     </a>
76 |                 </li>
77 |             </ul>
78 |         </div>
79 |     </div>
80 | </div>
81 | 


--------------------------------------------------------------------------------
/.docs/.themes/yeti/toc.html:
--------------------------------------------------------------------------------
 1 | <div class="bs-sidebar hidden-print affix well" role="complementary">
 2 |     <ul class="nav bs-sidenav">
 3 |     {% for toc_item in toc %}
 4 |         <li class="main {% if toc_item.active %}active{% endif %}"><a href="{{ toc_item.url }}">{{ toc_item.title }}</a></li>
 5 |         {% for toc_item in toc_item.children %}
 6 |             <li><a href="{{ toc_item.url }}">{{ toc_item.title }}</a></li>
 7 |         {% endfor %}
 8 |     {% endfor %}
 9 |     </ul>
10 | </div>
11 | 


--------------------------------------------------------------------------------
/.docs/about/contributing.md:
--------------------------------------------------------------------------------
 1 | # Contributing to ScaleIO-Framework
 2 | 
 3 | How can I contribute?
 4 | 
 5 | ---
 6 | 
 7 | The ScaleIO-Framework project welcomes, and depends, on contributions from
 8 | developers and users in the open source community. Contributions can be made in
 9 | a number of ways, a few examples are:
10 | 
11 | - Code patches via pull requests
12 | - Documentation improvements
13 | - Bug reports and patch reviews
14 | 
15 | ## Reporting an Issue
16 | 
17 | Please include as much detail as you can. This includes:
18 | 
19 |   * The OS type and version
20 |   * The ScaleIO-Framework commit
21 |   * The storage, scheduler and container system in question
22 |   * A set of logs with debug-logging enabled that show the problem
23 | 
24 | ## Submitting Pull Requests
25 | 
26 | Once you are happy with your changes or you are ready for some feedback, push
27 | it to your fork and send a pull request. For a change to be accepted it will
28 | most likely need to have tests and documentation if it is a new feature.
29 | 


--------------------------------------------------------------------------------
/.docs/about/license.md:
--------------------------------------------------------------------------------
 1 | # Licensing
 2 | 
 3 | The legal stuff
 4 | 
 5 | ---
 6 | 
 7 | ## ScaleIO-Framework License
 8 | Licensed under the Apache License, Version 2.0 (the “License”); you may not use
 9 | this file except in compliance with the License. You may obtain a copy of the
10 | License at <http://www.apache.org/licenses/LICENSE-2.0>
11 | 
12 | Unless required by applicable law or agreed to in writing, software distributed
13 | under the License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR
14 | CONDITIONS OF ANY KIND, either express or implied. See the License for the
15 | specific language governing permissions and limitations under the License.
16 | 


--------------------------------------------------------------------------------
/.docs/about/release-notes.md:
--------------------------------------------------------------------------------
  1 | # Release Notes
  2 | 
  3 | What's changed?
  4 | 
  5 | ---
  6 | 
  7 | ## Upgrading
  8 | 
  9 | To upgrade the ScaleIO-Framework to the latest version, simply redeploy the
 10 | Framework using the Marathon JSON based on the release you want to target. For
 11 | example, if you are currently running version 0.1.0 and want to upgrade to 0.2.0,
 12 | upgrading would simply consist of curl'ing the following JSON to Marathon:
 13 | 
 14 | ```
 15 | {
 16 |   "id": "scaleio-scheduler",
 17 |   "uris": [
 18 |     "https://github.com/codedellemc/scaleio-framework/releases/download/v0.2.0/scaleio-scheduler",
 19 |     "https://github.com/codedellemc/scaleio-framework/releases/download/v0.2.0/scaleio-executor"
 20 |   ],
 21 |   "cmd": "chmod u+x scaleio-scheduler && ./scaleio-scheduler -loglevel=debug -rest.port=$PORT -uri=[IP ADDRESS FOR MESOS MASTER]:5050 -scaleio.clustername=[SCALEIO NAME] -scaleio.password=[SCALEIO GATEWAY PASSWORD] -scaleio.preconfig.primary=[MASTER MDM IP ADDRESS] -scaleio.preconfig.secondary=[SLAVE MDM IP ADDRESS] -scaleio.preconfig.tiebreaker=[TIEBREAKER MDM IP ADDRESS] -scaleio.preconfig.gateway=[GATEWAY IP ADDRESS]",
 22 |   "mem": 32,
 23 |   "cpus": 0.2,
 24 |   "instances": 1,
 25 |   "constraints": [
 26 |     ["hostname", "UNIQUE"]
 27 |   ]
 28 | }
 29 | ```
 30 | 
 31 | Use the following REST API to determine the currently installed version of the
 32 | ScaleIO-Framework:
 33 | 
 34 | ```
 35 | GET [SCHEDULER IP/FQDN]:[Marathon Dynamic Port]/version
 36 | 
 37 | {
 38 |   "versionint": 1,
 39 |   "versionstr": "0.2.0"
 40 | }
 41 | ```
 42 | 
 43 | ## Version 0.3.1 (2017/02/28)
 44 | ScaleIO Framework 0.3.1 introduces a couple of experimental features.
 45 | 
 46 | ### Experimental
 47 | - Issue [#67](https://github.com/codedellemc/scaleio-framework/issues/67): (Experimental) Provision entire ScaleIO cluster. Please see the new experimental section in the documentation for more details.
 48 | - Issue [#73](https://github.com/codedellemc/scaleio-framework/issues/73): (Experimental) Self Remediation in AWS. Please see the new experimental section in the documentation for more details.
 49 | 
 50 | ## Version 0.3.0 (2017/01/10)
 51 | ScaleIO Framework 0.3.0 introduces the new Imperative approach for deploying ScaleIO.
 52 | 
 53 | ### New Features
 54 | - Addressed Issue [#82](https://github.com/codedellemc/scaleio-framework/issues/82): Implement User Defined Deployment. Please see PR [#111](https://github.com/codedellemc/scaleio-framework/pull/111) for more details.
 55 | - Addressed Issue [#95](https://github.com/codedellemc/scaleio-framework/issues/95): Create a RHEL7 Version of Cloud Formation Template that can be used for demos, testing, etc. RHEL7 will be the preferred platform for development and testing.
 56 | - Addressed Issue [#103](https://github.com/codedellemc/scaleio-framework/issues/103): Full Framework documentation is available on [Read the Docs](http://scaleio-framework.readthedocs.org/en/stable/).
 57 | 
 58 | ### Enhancements
 59 | - Another feature that has been enhanced is that when new nodes are brought online, storage devices will be add to the ScaleIO cluster based on the method being used.
 60 |   - If the Imperative approach is used, only devices defined by the user will be added.
 61 |   - The old automatic method is used, any available block devices that are currently not being used (ie has a filesystem on it) will be added to the default domain/pool.
 62 | - Addressed Issue [#71](https://github.com/codedellemc/scaleio-framework/issues/71): Instead of using elastic ips, each mesos node has been configured to dynamically modify required files (such as hostname, etc) on boot and then start the mesos services.
 63 | - Updated the CloudFormation template for Ubuntu to use ScaleIO 2.0.1.
 64 | 
 65 | ## Version 0.2.0 (2016/11/09)
 66 | ScaleIO Framework 0.2.0 introduces RHEL7/CentOS7 support and also refreshes the version of ScaleIO to version 2.0.1 which is the latest as of writting this release..
 67 | 
 68 | ### New Features
 69 | - Addressed Issue [#65](https://github.com/codedellemc/scaleio-framework/issues/65): RHEL7 and CentOS7 Support. Supports ScaleIO 2.0.1
 70 | - Addressed Issue [#91](https://github.com/codedellemc/scaleio-framework/issues/91): Updated Ubuntu14 to support ScaleIO 2.0.1. The CloudFormation template in the demo folder has also been updated to handle ScaleIO 2.0.1.
 71 | - Fixed Issue [#93](https://github.com/codedellemc/scaleio-framework/pull/93): The REX-ray configuration file that is created follows the suggested best practices.
 72 | - Added an intelligent reboot feature which will fix a reboot timing issue when the ScaleIO node that is running the scheduler is rebooted before other nodes have had the opportunity to contact it for the current state. I have not seen this happen yet, but there was certainly the possibility. That has been resolved now.
 73 | 
 74 | ### Enhancements
 75 | - Massive restructuring to the executor. This was largely in part due to time to market release of 0.1.0. With addition of RHEL7/CentOS7 support, the project needed to be restructured to support multiple platforms in a maintainable fashion.
 76 | - Removed the following flags. This is largely in part to due differences with both DEB and RPM package managers (in command and operational behavior) between versions of platforms (ie RHEL6 vs RHEL7).
 77 |   - scaleio.deb.mdm
 78 |   - scaleio.deb.sds
 79 |   - scaleio.deb.sdc
 80 |   - scaleio.deb.lia
 81 |   - scaleio.deb.gw
 82 |   - scaleio.rpm.mdm
 83 |   - scaleio.rpm.sds
 84 |   - scaleio.rpm.sdc
 85 |   - scaleio.rpm.lia
 86 |   - scaleio.rpm.gw
 87 | - Added platform specific flags for the ScaleIO packages. This is largely in part due to each platform having a different DEB or RPM between platform versions. Added the following flags:
 88 |   - scaleio.ubuntu14.mdm
 89 |   - scaleio.ubuntu14.sds
 90 |   - scaleio.ubuntu14.sdc
 91 |   - scaleio.ubuntu14.lia
 92 |   - scaleio.ubuntu14.gw
 93 |   - scaleio.rhel7.mdm
 94 |   - scaleio.rhel7.sds
 95 |   - scaleio.rhel7.sdc
 96 |   - scaleio.rhel7.lia
 97 |   - scaleio.rhel7.gw
 98 | - Renamed the following 3 flags to match the CPU flags.
 99 |   - executor.memory.mdm -> executor.mem.mdm
100 |   - executor.memory.no -> executor.mem.non
101 |   - executor.memoryfactor -> executor.memfactor
102 | - Added a new flag "Debug" to help with debugging the scheduler and executor. Among some of the things the debug flag does is prevent the reboot of the Mesos Agent node.
103 | - Fixed Issues [#94](https://github.com/codedellemc/scaleio-framework/issues/94) and [#72]( https://github.com/codedellemc/scaleio-framework/issues/72): Documentation related changes.
104 | 
105 | ### Bug Fixes
106 | - Supports Mesos Master leader changes. Implements the Mesos Master redirect functionality to connect to a different master.
107 | - Fixed an issue that sometimes caused REX-Ray not to start on reboot. Placed additional dependencies on ScaleIO scini driver.
108 | 
109 | ## Version 0.1.0 (2016/09/28)
110 | 
111 | Initial Release
112 | 


--------------------------------------------------------------------------------
/.docs/developer-guide/build-reference.md:
--------------------------------------------------------------------------------
  1 | # Build Reference
  2 | 
  3 | How to build the ScaleIO-Framework
  4 | 
  5 | ---
  6 | 
  7 | ## Build Requirements
  8 | This project has very few build requirements, but there are still one or two
  9 | items of which to be aware. Also, please note that these are the requirements to
 10 | *build* `ScaleIO-Framework`, not run it.
 11 | 
 12 | Requirement | Version
 13 | ------------|--------
 14 | Operating System | Linux, OSX
 15 | [Go](https://golang.org/) | >=1.7.3
 16 | 
 17 | ## Cross-Compilation
 18 | This project only currently supports running on Linux based platforms. Specifically
 19 | those outlined in the Requirements section on the main landing (aka README.md)
 20 | page. Although you can develop on OSX you will not be able to run on the OSX
 21 | platform.
 22 | 
 23 | ## Performing Builds
 24 | Building from source is pretty simple as all steps follow traditional golang
 25 | based projects. After forking the github project, there are two components that
 26 | make up the Framework, the scheduler and the executor. Simply navigate to each
 27 | directory and run the following build command:
 28 | `glide up && GOOS=linux GOARCH=amd64 go build .`
 29 | 
 30 | The output will look similar to the following:
 31 | 
 32 | ```sh
 33 | [INFO] Downloading dependencies. Please wait...
 34 | [INFO] Fetching updates for github.com/stretchr/testify.
 35 | [INFO] Fetching updates for github.com/Sirupsen/logrus.
 36 | [INFO] Fetching updates for github.com/dvonthenen/goxplatform.
 37 | [INFO] Setting version for github.com/stretchr/testify to v1.1.3.
 38 | [INFO] Setting version for github.com/Sirupsen/logrus to v0.10.0.
 39 | [INFO] Resolving imports
 40 | [INFO] Fetching golang.org/x/sys/unix into /Users/vonthd/go/src/github.com/codedellemc/scaleio-framework/scaleio-scheduler/vendor
 41 | [INFO] Fetching github.com/golang/protobuf/proto into /Users/vonthd/go/src/github.com/codedellemc/scaleio-framework/scaleio-scheduler/vendor
 42 | [INFO] Fetching github.com/gogo/protobuf/jsonpb into /Users/vonthd/go/src/github.com/codedellemc/scaleio-framework/scaleio-scheduler/vendor
 43 | [INFO] Fetching github.com/codegangsta/negroni into /Users/vonthd/go/src/github.com/codedellemc/scaleio-framework/scaleio-scheduler/vendor
 44 | [INFO] Fetching github.com/gorilla/mux into /Users/vonthd/go/src/github.com/codedellemc/scaleio-framework/scaleio-scheduler/vendor
 45 | [INFO] Fetching github.com/twinj/uuid into /Users/vonthd/go/src/github.com/codedellemc/scaleio-framework/scaleio-scheduler/vendor
 46 | [INFO] Fetching github.com/gorilla/context into /Users/vonthd/go/src/github.com/codedellemc/scaleio-framework/scaleio-scheduler/vendor
 47 | [INFO] Downloading dependencies. Please wait...
 48 | [INFO] Setting references for remaining imports
 49 | [INFO] Project relies on 10 dependencies.
 50 | ```
 51 | 
 52 | Upon completion of a successful build, you will not receive a "positive" notification
 53 | of that build, but rather you will find a completed binary at the root of the
 54 | folder.
 55 | 
 56 | ## Making modifications to source and building
 57 | If you plan on making changes to the source for developing or testing purposes,
 58 | you must follow a couple of prerequisites due to the layout of the project in
 59 | GitHub. Since there exists two projects in in the same repo in which one project,
 60 | the executor, depends on another, the scheduler, there currently is an issue with
 61 | glide when pulling those dependencies for each project. To remedy the issue for
 62 | private builds, you must:
 63 | 
 64 | 1. Fork the project
 65 | 2. Clone your fork into your own workspace
 66 | 3. Create a git branch, make your changes and push your branch to your private repo
 67 | 4. Run the ./switch.sh file which swaps the current glide.yaml with glide.yaml.dev
 68 | 5. Then open the glide.yaml and replace the repo and ref properties of the scaleio-framework package with your fork and the commit you want to build against.
 69 |   ```
 70 |   - package: github.com/codedellemc/scaleio-framework
 71 |     ref:     a8a1be0c946a19f97fdc962150626186f3315078
 72 |     vcs:     git
 73 |     repo:    https://github.com/dvonthenen/scaleio-framework
 74 |   ```
 75 | 6. Then run ./build.sh. If the glide step fails, re-run the ./build.sh command.
 76 | 
 77 | ## Version File
 78 | There is a file at the root of the project named `VERSION`. The file contains
 79 | a single line with the *target* version of the project in the file. The version
 80 | follows the format:
 81 | 
 82 |   `(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(-rc\d+)?`
 83 | 
 84 | For example, during active development of version `0.1.0` the file would
 85 | contain the version `0.1.0`. When it's time to create `0.4.0`'s first
 86 | release candidate the version in the file will be changed to `0.1.0-rc1`. And
 87 | when it's time to release `0.1.0` the version is changed back to `0.1.0`.
 88 | 
 89 | Please note that we've discussed making the actively developed version the
 90 | targeted version with a `-dev` suffix, but trying this resulted in confusion
 91 | for the RPM and DEB package managers when using `unstable` releases.
 92 | 
 93 | So what's the point of the file if it's basically duplicating the utility of a
 94 | tag? Well, the `VERSION` file in fact has two purposes:
 95 | 
 96 |   1. First and foremost updating the `VERSION` file with the same value as that
 97 |      of the tag used to create a release provides a single, contextual reason to
 98 |      push a commit and tag. Otherwise some random commit off of `master` would
 99 |      be tagged as a release candidate or release. Always using the commit that
100 |      is related to updating the `VERSION` file is much cleaner.
101 | 
102 |   2. The contents of the `VERSION` file are also used during the build process
103 |      as a means of overriding the output of a `git describe`. This enables the
104 |      semantic version injected into the produced binary to be created using
105 |      the *targeted* version of the next release and not just the value of the
106 |      last, tagged commit.
107 | 


--------------------------------------------------------------------------------
/.docs/developer-guide/project-guidelines.md:
--------------------------------------------------------------------------------
  1 | # Project Guidelines
  2 | 
  3 | These are important.
  4 | 
  5 | ---
  6 | 
  7 | People contributing code to this project must adhere to the following rules.
  8 | These standards are in place to keep code clean, consistent, and stable.
  9 | 
 10 | ## Documentation
 11 | There are two types of documentation: source and markdown.
 12 | 
 13 | ### Source Code
 14 | All source code should be documented in accordance with the
 15 | [Go's documentation rules](http://blog.golang.org/godoc-documenting-go-code).
 16 | 
 17 | ### Markdown
 18 | When creating or modifying the project's `README.md` file or any of the
 19 | documentation in the `.docs` directory, please keep the following rules in
 20 | mind:
 21 | 
 22 | 1. All links to internal resources should be relative.
 23 | 2. All links to markdown files should include the file extension.
 24 | 
 25 | For example, the below link points to the anchor `basic-configuration` on the
 26 | `Configuration` page:
 27 | 
 28 | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 29 | [/user-guide/configuration#basic-configuration](/user-guide/configuration#basic-configuration)
 30 | 
 31 | However, when the above link is followed when viewing this page directly from
 32 | the Github repository instead of the generated site documentation, the link
 33 | will return a 404.
 34 | 
 35 | While it's recommended that users view the generated site documentation instead
 36 | of the source Markdown directly, we can still fix it so that the above link
 37 | will work regardless. To fix the link, simply make it relative and add the
 38 | Markdown file extension:
 39 | 
 40 | &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
 41 | [../user-guide/configuration.md#basic-configuration](../user-guide/configuration.md#basic-configuration)
 42 | 
 43 | Now the link will work regardless from where it's viewed.
 44 | 
 45 | ## Style & Syntax
 46 | All source files should be processed by the following tools prior to being
 47 | committed. Any errors or warnings produced by the tools should be corrected
 48 | before the source is committed.
 49 | 
 50 | Tool | Description
 51 | -----|------------
 52 | [gofmt](https://golang.org/cmd/gofmt/) | A golang source formatting tool
 53 | [golint](https://github.com/golang/lint) | A golang linter
 54 | [govet](https://golang.org/cmd/vet/) | A golang source optimization tool
 55 | [gocyclo](https://github.com/fzipp/gocyclo) | A golang cyclomatic complexity detection tool. No function should have a score above 0.15
 56 | 
 57 | It [Visual Studio Code](https://code.visualstudio.com/) is your IDE of choice,
 58 | install the [vscode-go](https://github.com/Microsoft/vscode-go) package, and it
 59 | will execute all of the tools above upon saving a file.
 60 | 
 61 | If [Atom](https://atom.io/) is your IDE of choice, install the
 62 | [go-plus](https://atom.io/packages/go-plus) package, and it will execute all of
 63 | the tools above less gocyclo upon saving a file.
 64 | 
 65 | In lieu of using Atom as the IDE, the project's build procedures as outlined in
 66 | [build-references.md](build-references.md) automatically
 67 | executes the above tools as part of the build process and will fail the build
 68 | if problems are discovered.
 69 | 
 70 | ## Code Coverage
 71 | All new work submitted to the project should have associated tests where
 72 | applicable. If there is ever a question of whether or not a test is applicable
 73 | then the answer is likely yes.
 74 | 
 75 | This project uses
 76 | [Codecov](https://codecov.io/github/codedellemc/scaleio-framework?branch=master)
 77 | for code coverage, and all pull requests are processed just as a build from `master`.
 78 | If a pull request decreases the project's code coverage, the pull request will be
 79 | declined until such time that testing is added or enhanced to compensate.
 80 | 
 81 | ## Commit Messages
 82 | Commit messages should follow the guide [5 Useful Tips For a Better Commit
 83 | Message](https://robots.thoughtbot.com/5-useful-tips-for-a-better-commit-message).
 84 | The two primary rules to which to adhere are:
 85 | 
 86 |   1. Commit message subjects should not exceed 50 characters in total and
 87 |      should be followed by a blank line.
 88 | 
 89 |   2. The commit message's body should not have a width that exceeds 72
 90 |      characters.
 91 | 
 92 | For example, the following commit has a very useful message that is succinct
 93 | without losing utility.
 94 | 
 95 | ```
 96 | commit e80c696939a03f26cd180934ba642a729b0d2941
 97 | Date:   Tue Oct 20 23:47:36 2015 -0500
 98 | 
 99 |     Added --format,-f option for CLI
100 | 
101 |     This patch adds the flag '--format' or '-f' for the
102 |     following CLI commands:
103 | 
104 |         * adapter instances
105 |         * device [get]
106 |         * snapshot [get]
107 |         * snapshot copy
108 |         * snapshot create
109 |         * volume [get]
110 |         * volume attach
111 |         * volume create
112 |         * volume map
113 |         * volume mount
114 |         * volume path
115 | 
116 |     The user can specify either '--format=yml|yaml|json' or
117 |     '-f yml|yaml|json' in order to influence how the resulting,
118 |     structured data is marshaled prior to being emitted to the console.
119 | ```
120 | 
121 | Please note that the output above is the full output for viewing a commit.
122 | However, because the above message adheres to the commit message rules, it's
123 | quite easy to show just the commit's subject:
124 | 
125 | ```
126 | $ git show e80c696939a03f26cd180934ba642a729b0d2941 --format="%s" -s
127 | Added --format,-f option for CLI
128 | ```
129 | 
130 | It's also equally simple to print the commit's subject and body together:
131 | 
132 | ```
133 | $ git show e80c696939a03f26cd180934ba642a729b0d2941 --format="%s%n%n%b" -s
134 | Added --format,-f option for CLI
135 | 
136 | This patch adds the flag '--format' or '-f' for the
137 | following CLI commands:
138 | 
139 |     * adapter instances
140 |     * device [get]
141 |     * snapshot [get]
142 |     * snapshot copy
143 |     * snapshot create
144 |     * volume [get]
145 |     * volume attach
146 |     * volume create
147 |     * volume map
148 |     * volume mount
149 |     * volume path
150 | 
151 | The user can specify either '--format=yml|yaml|json' or
152 | '-f yml|yaml|json' in order to influence how the resulting,
153 | structured data is marshaled prior to being emitted to the console.
154 | ```
155 | 
156 | ## Submitting Changes
157 | All developers are required to follow the
158 | [GitHub Flow model](https://guides.github.com/introduction/flow/) when
159 | proposing new features or even submitting fixes.
160 | 
161 | Please note that although not explicitly stated in the referenced GitHub Flow
162 | model, all work should occur on a __fork__ of this project, not from within a
163 | branch of this project itself.
164 | 
165 | Pull requests submitted to this project should adhere to the following
166 | guidelines:
167 | 
168 |   * Branches should be rebased off of the upstream master prior to being
169 |     opened as pull requests and again prior to merge. This is to ensure that
170 |     the build system accounts for any changes that may only be detected during
171 |     the build and test phase.
172 | 
173 |   * Unless granted an exception a pull request should contain only a single
174 |     commit. This is because features and patches should be atomic -- wholly
175 |     shippable items that are either included in a release, or not. Please
176 |     squash commits on a branch before opening a pull request. It is not a
177 |     deal-breaker otherwise, but please be prepared to add a comment or
178 |     explanation as to why you feel multiple commits are required.
179 | 


--------------------------------------------------------------------------------
/.docs/developer-guide/release-process.md:
--------------------------------------------------------------------------------
  1 | # Release Process
  2 | 
  3 | How to release ScaleIO-Framework
  4 | 
  5 | ---
  6 | 
  7 | ## Project Stages
  8 | This project has three parallels stages of release:
  9 | 
 10 | Name | Description
 11 | -----|------------
 12 | `unstable` | The tip or HEAD of the `master` branch is referred to as `unstable`
 13 | `staged` | A commit tagged with the suffix `-rc\d+` such as `v0.1.0-rc2` is a `staged` release. These are release candidates.
 14 | `stable` | A commit tagged with a version sans `-rc\d+` suffix such as `v0.1.0` is a `stable` release.
 15 | 
 16 | There are no steps necessary to create an `unstable` release as that happens
 17 | automatically whenever an untagged commit is pushed to `master`. However, the
 18 | following workflow should be used when tagging a `staged` release candidate
 19 | or `stable` release.
 20 | 
 21 |   1. Review outstanding issues & pull requests
 22 |   2. Prepare release notes
 23 |   3. Update the version file
 24 |   4. Commit & pull request
 25 |   5. Tag the release
 26 |   6. Update the version file (again)
 27 | 
 28 | ## Review Issues & Pull Requests
 29 | The first step to a release is to review the outstanding
 30 | [issues](https://github.com/codedellemc/scaleio-framework/issues) and
 31 | [pull requests](https://github.com/codedellemc/scaleio-framework/pulls) that are
 32 | tagged for the release in question.
 33 | 
 34 | If there are outstanding issues requiring changes or pending pull requests to
 35 | be merged, handle those prior to tagging any commit as a release candidate or
 36 | release.
 37 | 
 38 | It is __highly__ recommended that pull requests be merged synchronously after
 39 | rebasing each subsequent one off of the new tip of `master`. Remember, while
 40 | GitHub will update a pull request as in conflict if a change to `master`
 41 | results in a merge conflict with the pull request, GitHub will __not__ force a
 42 | new build to spawn unless the pull request is actually updated.
 43 | 
 44 | At the very minimum a pull request's build should be re-executed prior to the
 45 | pull request being merged if `master` has changed since the pull request was
 46 | opened.
 47 | 
 48 | ## Prepare Release Notes
 49 | Update the release notes at `.docs/about/release-notes.md`. This file is
 50 | project's authoritative changelog and should reflect new features, fixes, and
 51 | any significant changes.
 52 | 
 53 | The most recent, `stable` version of the release notes are always available
 54 | online at
 55 | [ScaleIO-Framework's documentation site](http://scaleio-framework.rtfd.org/en/stable/about/release-notes/).
 56 | 
 57 | ## Update Version File
 58 | The `VERSION` file exists at the root of the project and should be updated to
 59 | reflect the value of the intended release.
 60 | 
 61 | For example, if creating the first release candidate for version 0.1.0, the
 62 | contents of the `VERSION` file should be a single line `0.1.0-rc1` followed by
 63 | a newline character:
 64 | 
 65 | ```sh
 66 | $ cat VERSION
 67 | 0.1.0-rc1
 68 | ```
 69 | 
 70 | If releasing version 0.1.0 proper then the contents of the `VERSION` file
 71 | should be `0.1.0` followed by a newline character:
 72 | 
 73 | ```sh
 74 | $ cat VERSION
 75 | 0.1.0
 76 | ```
 77 | 
 78 | ## Commit & Pull Request
 79 | Once all outstanding issues and pull requests are handled, the release notes
 80 | and version are updated, it's time to create a commit.
 81 | 
 82 | Please make sure that the changes to the release notes and version files are
 83 | a part of the same commit. This makes identifying the aspects of a release,
 84 | staged or otherwise, far easier for future developers.
 85 | 
 86 | A release's commit message can either be a reflection of the release notes or
 87 | something simple. Either way the commit message should have the following
 88 | subject format and first line in its body:
 89 | 
 90 | ```text
 91 | Release (Candidate) v0.1.0-rc1
 92 | 
 93 | This patch bumps the version to v0.1.0-rc1.
 94 | ```
 95 | 
 96 | If the commit message is longer it should simply reflect the same information
 97 | from the release notes.
 98 | 
 99 | Once committed push the change to a fork and open a pull request. Even though
100 | this commit marks a staged or official release, the pull request system is still
101 | used to assure that the build completes successfully and there are no unforeseen
102 | errors.
103 | 
104 | ## Tag the Release
105 | Once the pull request marking the `staged` or `stable` release has been merged
106 | into `upstream`'s `master` it's time to tag the release.
107 | 
108 | ### Tag Format
109 | The release tag should follow a prescribed format depending upon the release
110 | type:
111 | 
112 | Release Type | Tag Format | Example
113 | --------|---------|---------
114 | `staged`  | vMAJOR.MINOR.PATCH-rc[0-9] | v0.1.0-rc1
115 | `stable`  | vMAJOR.MINOR-PATCH | v0.1.0
116 | 
117 | ### Tag Methods
118 | There are two ways to tag a release:
119 | 
120 |   1. [GitHub Releases](https://github.com/codedellemc/scaleio-framework/releases/new)
121 |   2. Command Line
122 | 
123 | ### Command Line
124 | If tagging a release via the command line be sure to fetch the latest changes
125 | from `upstream`'s `master` and either merge them into your local copy of
126 | `master` or reset the local copy to reflect `upstream` prior to creating
127 | any tags.
128 | 
129 | The following combination of commands can be used to create a tag for
130 | 0.1.0 Release Candidate 1:
131 | 
132 | ```sh
133 | git fetch upstream && \
134 |   git checkout master && \
135 |   git reset --hard upstream/master && \
136 |   git tag -a -m v0.1.0-rc1 v0.1.0-rc1
137 | ```
138 | 
139 | The above example combines a few operations:
140 | 
141 |   1. The first command fetches the `upstream` changes
142 |   2. The local `master` branch is checked out
143 |   3. The local `master` branch is hard reset to `upstream/master`
144 |   4. An annotated tag is created on `master` for `v0.1.0-rc1`, or 0.1.0 Release
145 |      Candidate 1, with a tag message of `v0.1.0-rc1`.
146 | 
147 | Please note that the third step will erase any changes that exist only in the
148 | local `master` branch that do not also exist in the remote, upstream copy.
149 | However, if the two branches are not equal this method should not be used to
150 | create a tag anyway.
151 | 
152 | The above steps do not actually push the tag upstream. This is to allow for one
153 | final review of all the changes before doing so since the appearance of a new,
154 | annotated tag in the repository will cause the project's build system to
155 | automatically kick off a build that will result in the release of a `staged` or
156 | `stable` release. For `stable` releases the project's documentation will also be
157 | updated.
158 | 
159 | Once positive everything looks good simply execute the following command to
160 | push the tag to the `upstream` repository:
161 | 
162 | ```sh
163 | git push upstream v0.1.0-rc1
164 | ```
165 | 
166 | ## Update Version File (Again)
167 | After a release is tagged there is one final step involving the `VERSION` file.
168 | The contents of the file should be updated to reflect the next, targeted release
169 | so that the produced artifacts reflect the targeted version value and not a
170 | value based on the last, tagged commit.
171 | 
172 | Following the above examples where version `v0.1.0-rc1` was just staged, the
173 | `VERSION` file should be updated to indicate that 0.1.0 Release Candidate 2
174 | (`0.1.0-rc2`) is the next, targeted release:
175 | 
176 | ```sh
177 | $ cat VERSION
178 | 0.1.0-rc2
179 | ```
180 | 
181 | Commit the change to the `VERSION` file with a commit message similar to the
182 | following:
183 | 
184 | ```text
185 | Bumped active dev version to v0.1.0-rc2
186 | 
187 | This patch bumps the active dev version to v0.1.0-rc2.
188 | ```
189 | 
190 | Once the `VERSION` file change is committed, push the change and open a pull
191 | request to merge into the project.
192 | 


--------------------------------------------------------------------------------
/.docs/developer-guide/restapi.md:
--------------------------------------------------------------------------------
1 | # REST API
2 | 
3 | The ScaleIO-Framework REST API documentation at Apiary!
4 | 
5 | ## TODO
6 | 
7 | Coming soon!
8 | 


--------------------------------------------------------------------------------
/.docs/images/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thecodeteam/scaleio-framework/3fb79e9a2a1a130ca0fd201678a9fbaf92243d0e/.docs/images/logo.png


--------------------------------------------------------------------------------
/.docs/images/marathon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thecodeteam/scaleio-framework/3fb79e9a2a1a130ca0fd201678a9fbaf92243d0e/.docs/images/marathon.png


--------------------------------------------------------------------------------
/.docs/images/status.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thecodeteam/scaleio-framework/3fb79e9a2a1a130ca0fd201678a9fbaf92243d0e/.docs/images/status.png


--------------------------------------------------------------------------------
/.docs/index.md:
--------------------------------------------------------------------------------
 1 | # ScaleIO-Framework for Apache Mesos
 2 | 
 3 | ![ScaleIO-Framework](images/logo.png)
 4 | 
 5 | ## Overview
 6 | The `ScaleIO Framework` deploys Dell EMC ScaleIO as a simplified task in Apache
 7 | Mesos. All the required components to consume and provision storage volumes from
 8 | a ScaleIO cluster are automatically deployed and configured on the Mesos Agents.
 9 | This creates an automated mechanism to have a fully configured and reliable
10 | persistent storage solution for containers running on Apache Mesos.
11 | 
12 | ## Key Features
13 | - Installs required components on existing Mesos Agents to consume and provision ScaleIO storage volumes
14 | - On-boards new Agent nodes with *"native"* access to ScaleIO volumes
15 | - All Agent nodes are configured to be highly available so failed applications can be restarted on other Agent nodes while preserving their data using [REX-Ray](https://github.com/codedellemc/rexray) as a container runtime volume driver
16 | - Additional storage can be added to the ScaleIO cluster to expand capacity
17 | 
18 | ## What it does
19 | Container runtime schedulers need to be integrated with every aspect of available
20 | hardware resources, including persistent storage. When requesting resources for
21 | an application the scheduler gets offers for CPU, RAM and disk.
22 | 
23 | To be able to offer persistent storage in a scalable way, the ScaleIO Framework
24 | installs and configures all necessary ScaleIO, a Software-based Storage Platform,
25 | components along with all the "glue" to connect Mesos and ScaleIO to service
26 | applications requiring persistent storage.
27 | 
28 | ## Framework workflow
29 | 
30 | What does the ScaleIO Framework really do under the covers? Up to this point,
31 | its been stated that the Framework automates the lifecycle of ScaleIO and any
32 | related components required to provision external persistent storage in a "run
33 | it and forget it" fashion, but what does that really mean?
34 | 
35 | The ScaleIO Framework performs the following steps on deployment. It installs
36 | and configures:
37 | 
38 | 1. Any dependencies required for ScaleIO to run. This is done via apt-get or yum.
39 | 2. The ScaleIO SDS (or Server) package. This is the service that takes designated disks (physical or virtual) and contributes them to the ScaleIO cluster.
40 | 3. The ScaleIO SDC (or Client) package. This is the service that provides access to ScaleIO volumes created within the ScaleIO cluster.
41 | 4. [REX-Ray](https://github.com/codedellemc/rexray) which provides Mesos the ability to provision external storage for tasks that are backed by Docker containers.
42 | 5. [mesos-module-dvdi](https://github.com/emccode/mesos-module-dvdi) and [DVDCLI](https://github.com/emccode/dvdcli) which provides Mesos the ability to provision external storage for tasks that using the Mesos Universal Containerizer. This includes any configuration required on the Mesos Agent nodes.
43 | 
44 | ## Installation and Configuration
45 | Installation is fairly simple as it only requires a simple `curl` command to
46 | deploy the Framework. There are some prerequisites that are required however. You
47 | can find more information on the [Installation Page](/user-guide/installation.md).
48 | There are various [configuration options](/user-guide/configuration.md) available
49 | as well that will allow you to tune and customize your deployment of ScaleIO.
50 | 
51 | ## Hello ScaleIO-Framework
52 | Looking for a video demo or to get some hands on experience with demo environment?
53 | Take a look in the [Users Guide](/user-guide/demo.md) section for instructions
54 | to quickly prop up an environment quickly.
55 | 
56 | ## Getting Help
57 | Having issues? No worries, let's figure it out together.
58 | 
59 | ### GitHub and Slack
60 | If a little extra help is needed, please don't hesitate to use
61 | [GitHub issues](https://github.com/codedellemc/scaleio-framework/issues) or join
62 | the active conversation on the
63 | [{code} Community Slack Team](http://community.codedellemc.com/) in the #mesos
64 | channel
65 | 


--------------------------------------------------------------------------------
/.docs/user-guide/configuration.md:
--------------------------------------------------------------------------------
  1 | # Configuration
  2 | 
  3 | What are the Framework's configuration options?
  4 | 
  5 | ---
  6 | 
  7 | ## Overview
  8 | 
  9 | This page reviews how to configure the ScaleIO-Framework. We will first cover the
 10 | command line option and delving into the details of more advanced settings.
 11 | 
 12 | ## Basic Command Line Options
 13 | 
 14 | Basic command line options available...
 15 | 
 16 | `-loglevel=[debug|info|warn|error]`  
 17 | Optional: Set the logging level for the application. Default: info
 18 | 
 19 | `-debug=[true|false]`  
 20 | Optional: Debug mode prevents the reboot so the logs dont get cycled. Default: false
 21 | 
 22 | `-rexray.branch=[stable|unstable|staged]`  
 23 | Optional: Which branch to grab the REX-Ray package from. Default: stable
 24 | 
 25 | `-rexray.version=[specific version|latest]`  
 26 | Optional: Which version to install from the provided branch. You can provide a
 27 | specific version such as 0.6.3. The default is the last build. Default: latest
 28 | 
 29 | `-isolator.binary=[specific version]`  
 30 | Optional: The URL for which Mesos Module DVDI to install. Default: latest supported
 31 | 
 32 | `-rest.address=`  
 33 | Optional: *Highly recommend not to modify* Mesos scheduler REST API address.
 34 | Default: Dynamically calculated.
 35 | 
 36 | `-rest.port=<port>`
 37 | Required: *Highly recommend using the dynamic Marathon port* Mesos scheduler
 38 | REST API port.
 39 | 
 40 | `-uri=<mesos master uri>`
 41 | Required: Mesos scheduler API URL. This is the Mesos Master HTTP API endpoint.
 42 | 
 43 | `-executor.cpu.factor=[float value]`  
 44 | Optional: Fudge factor for effective CPU available. This allows overhead/reserve.
 45 | A value of 1.0 means none of the CPU has been reserved. Default: 1.0
 46 | 
 47 | `-executor.mem.factor=[float value]`  
 48 | Optional: Fudge factor for effective memory available. This allows overhead/reserve.
 49 | A value of 1.0 means none of the memory has been reserved. Default: 1.0
 50 | 
 51 | `-store.type=[consul|etcd|zk|boltdb]`  
 52 | Optional: The type of keyvalue store to use. Default: zk
 53 | 
 54 | `-store.uri=[uri to connect to the key store based on store.type]`  
 55 | Optional: Store URI to connect with. When the value is an "empty string", the
 56 | framework will dynamically determine the zookeeper endpoints.
 57 | Default: "empty string"
 58 | 
 59 | `-scaleio.clustername=[cluster name]`  
 60 | Optional: ScaleIO Cluster Name. Default: scaleio
 61 | 
 62 | `-scaleio.clusterid=`  
 63 | Optional: ScaleIO Cluster ID. The priority of this flag supersedes scaleio.clustername
 64 | if used. Default: "empty string"
 65 | 
 66 | `-scaleio.lbgateway=[uri for the scaleio gateway]`  
 67 | Optional: Great to use if your ScaleIO gateway is clustered and load balanced.
 68 | If the value is "empty string", it is assumed that the ScaleIO is on the primary
 69 | MDM node. Default: "empty string"
 70 | 
 71 | `-scaleio.protectiondomain=[default pd name]`  
 72 | Optional: The default ScaleIO Protection Domain Name used. Default: default
 73 | 
 74 | `-scaleio.storagepool=[default sp name]`  
 75 | Optional: The default ScaleIO StoragePool Name used. Default: default
 76 | 
 77 | `-scaleio.password=[password]`  
 78 | Required: ScaleIO Admin Password. This is used to install all ScaleIO packages
 79 | that require a ScaleIO admin password, the password to access the ScaleIO gateway,
 80 | and etc. Default: Scaleio123
 81 | 
 82 | `-scaleio.preconfig.primary=<fqdn/ip of pri MDM node>`  
 83 | Required: FQDN or IP of the pre-configured Pri MDM Node. Requires Sec and TB MDM
 84 | nodes to be pre-configured
 85 | 
 86 | `-scaleio.preconfig.secondary=<fqdn/ip of sec MDM node>`  
 87 | Required: FQDN or IP of the pre-configured Sec MDM Node. Requires Pri and TB MDM
 88 | nodes to be pre-configured
 89 | 
 90 | `-scaleio.preconfig.tiebreaker=<fqdn/ip of sec MDM node>`  
 91 | Required: FQDN or IP of the pre-configured Tiebreaker MDM Node. Requires Pri and
 92 | Sec MDM nodes to be pre-configured
 93 | 
 94 | `-scaleio.preconfig.gateway=[fqdn/ip of ScaleIO gateway node]`  
 95 | Optional: Used to set a separate ScaleIO Gateway node. If the value is "empty string",
 96 | the Primary MDM node is assumed to have the Gateway installed on it.
 97 | Default: "empty string"
 98 | 
 99 | `-scaleio.ubuntu14.mdm=[URL for DEB]`  
100 | Optional: ScaleIO MDM Package for Ubuntu 14.04. Default: package tested in the release
101 | 
102 | `-scaleio.ubuntu14.sds=[URL for DEB]`  
103 | Optional: ScaleIO SDS Package for Ubuntu 14.04. Default: package tested in the release
104 | 
105 | `-scaleio.ubuntu14.sdc=[URL for DEB]`  
106 | Optional: ScaleIO SDC Package for Ubuntu 14.04. Default: package tested in the release
107 | 
108 | `-scaleio.ubuntu14.lia=[URL for DEB]`  
109 | Optional: ScaleIO LIA Package for Ubuntu 14.04. Default: package tested in the release
110 | 
111 | `-scaleio.ubuntu14.gw=[URL for DEB]`  
112 | Optional: ScaleIO Gateway Package for Ubuntu 14.04. Default: package tested in the release
113 | 
114 | `-scaleio.centos7.mdm=[URL for RPM]`  
115 | `-scaleio.rhel7.mdm=[URL for RPM]`
116 | Optional: ScaleIO MDM Package for RHEL7/CentOS7. Currently RHEL7 and CentOS7 are the same.
117 | Default: package tested in the release
118 | 
119 | `-scaleio.centos7.sds=[URL for RPM]`
120 | `-scaleio.rhel7.sds=[URL for RPM]`
121 | Optional: ScaleIO SDS Package for RHEL7/CentOS7. Currently RHEL7 and CentOS7 are the same.
122 | Default: package tested in the release
123 | 
124 | `-scaleio.centos7.sdc=[URL for RPM]`
125 | `-scaleio.rhel7.sdc=[URL for RPM]`
126 | Optional: ScaleIO SDC Package for RHEL7/CentOS7. Currently RHEL7 and CentOS7 are the same.
127 | Default: package tested in the release
128 | 
129 | `-scaleio.centos7.lia=[URL for RPM]`
130 | `-scaleio.rhel7.lia=[URL for RPM]`
131 | Optional: ScaleIO LIA Package for RHEL7/CentOS7. Currently RHEL7 and CentOS7 are the same.
132 | Default: package tested in the release
133 | 
134 | `-scaleio.centos7.gw=[URL for RPM]`
135 | `-scaleio.rhel7.gw=[URL for RPM]`
136 | Optional: ScaleIO Gateway Package for RHEL7/CentOS7. Currently RHEL7 and CentOS7 are the same.
137 | Default: package tested in the release
138 | 
139 | ## Advanced Command Line Options
140 | 
141 | Not going to lie... some of these command line option descriptions will be left
142 | intentional vague so you don't shoot yourself in the foot. No point in hiding them
143 | because you can just run a help on the command line. So in the interest in full
144 | disclosure, here they are.
145 | 
146 | Most of these options are highly recommended *NOT* to modify and/or use.
147 | 
148 | `-experimental=[true|false]`  
149 | Optional: Sets the application to experimental mode. Default: false
150 | 
151 | `-executor.altpath=[http path]`  
152 | Optional: This is to override the default location of the scaleio-executor binary.
153 | Default: "empty string"
154 | 
155 | `-executor.cpu.mdm=[float value]`  
156 | Optional: CPU resources consumed by ScaleIO MDM software.
157 | These are either the primary, secondary, or tiebreaker MDM nodes. Modifying
158 | these values may not earmark actually CPU consumed by the ScaleIO software. Default: 1.5
159 | 
160 | `-executor.cpu.non=[float value]`  
161 | Optional: CPU resources consumed by ScaleIO Non-MDM software.
162 | These are data nodes only. Modifying these values may not earmark actually CPU
163 | consumed by the ScaleIO software. Default: 0.5
164 | 
165 | `-executor.mem.mdm=[int value]`  
166 | Optional: Memory resources (MB) consumed by ScaleIO MDM software.
167 | These are either the primary, secondary, or tiebreaker MDM nodes. Modifying
168 | these values may not earmark actually memory consumed by the ScaleIO software.
169 | Default: 3072
170 | 
171 | `-executor.mem.non=[int value]`  
172 | Optional: Memory resources (MB) consumed by ScaleIO MDM software.
173 | These are data nodes only. Modifying these values may not earmark actually memory
174 | consumed by the ScaleIO software. Default: 512
175 | 
176 | `-user=[user to run the process under]`  
177 | Optional: The User account the framework is running under. Root is required in
178 | order to run administrative functions like installation of packages. Default: root
179 | 
180 | `-hostname=[hostname where the scheduler is running]`  
181 | Optional: The Hostname where the framework runs. This is only used for setting up
182 | a mock scheduler. Default: dynamically discovered
183 | 
184 | `-role=[role name]`  
185 | Optional: *Currently not supported* Framework role to register with the Mesos master.
186 | This will allow for multiple ScaleIO clusters to run in the same Mesos cluster. Default: scaleio
187 | 
188 | `-scaleio.apiversion=[ScaleIO API Version]`  
189 | Optional: ScaleIO API Version. Matches the API version of the ScaleIO software
190 | the framework installs. Default: 2.0
191 | 
192 | `-store.delete=<true|false>`  
193 | Optional: Helper function that deletes ScaleIO Framework Key/Value Store. Default: false
194 | 
195 | `-store.dump=<true|false>`  
196 | Optional: Helper function that dumps ScaleIO Framework Key/Value Store. Default: false
197 | 
198 | `-store.add.key=<key to add to store>`  
199 | Optional: Modify a select store key. Default: "empty string"
200 | 
201 | `-store.add.value=<value to add to the store>`  
202 | Optional: Set the values to the key provided by store.key. Default: "empty string"
203 | 
204 | `-store.del.key=<key to delete>`  
205 | Optional: Delete a select store key. Default: "empty string"
206 | 


--------------------------------------------------------------------------------
/.docs/user-guide/demo.md:
--------------------------------------------------------------------------------
  1 | # ScaleIO Framework Demo
  2 | 
  3 | If you are looking for a demo or a quick and easy dev/test environment, this might be for you!
  4 | 
  5 | ---
  6 | 
  7 | ## Configuration
  8 | 
  9 | The requirements of having a 3-Node ScaleIO cluster along with an Apache Mesos
 10 | Master and Agent cluster would heavily resource constrain a laptop or computer
 11 | used for local development. An [AWS CloudFormation template](Framework_Testing_Cluster_RHEL7.json)
 12 | is provided that deploys and installs a fully configured Dell EMC ScaleIO and
 13 | Apache Mesos cluster on Amazon AWS. This template currently works in the
 14 | **US-West-1 (aka N.California) region only**.
 15 | 
 16 | *NOTE: Deploying this template uses six (6) `t2.medium` instances in the N.California
 17 | region, costing $0.068/hour. The AWS EC2 compute usage for this cluster will
 18 | cost approximately $9.78/day. The template provisions nine (9) EBS volumes in
 19 | total. Six (6) for the operating systems and three (3) 100-gigabyte volumes for
 20 | ScaleIO storage.*
 21 | 
 22 | Steps:
 23 | 1. Deploy The CloudFormation Template
 24 | 2. Verify ScaleIO Configuration
 25 | 3. Launch Framework
 26 | 4. Deploy Applications
 27 | 
 28 | Watch the [YouTube Demo Video](https://youtu.be/tt6qhEkeVOQ?list=PLbssOJyyvHuWiBQAg9EFWH570timj2fxt) to see it in action.
 29 | 
 30 | ### Deploy CloudFormation Template
 31 | 
 32 | The password for administrator rights is `F00barbaz`. Both the ScaleIO and Mesos
 33 | nodes are deployed using Redhat 7.X instances. The usernames used to log into
 34 | any those systems via ssh are `ec2-user`.
 35 | 
 36 | Within the AWS Web GUI:
 37 | 
 38 | 1. Verify you are in the N. California region.
 39 | 2. Within the drop-down of `Services` choose `CloudFormation`
 40 | 3. Click `Create Stack`, then `Choose a Template`
 41 | 4. Click `Upload file to S3`, and upload [Framework_Testing_Cluster_RHEL7.json](Framework_Testing_Cluster_RHEL7.json)
 42 | 5. Give the stack a unique name (such as: MesosFrameworkDemo)
 43 | 6. Select a keypair that exists in the **N.California region**
 44 | 7. Click `next`. Tags are optional. Click `next`
 45 | 8. Review the settings and click `Create` to create the stack
 46 | 
 47 | The stack will take approximately two minutes to build and the nodes will be
 48 | available for ssh login.
 49 | 
 50 | ### Verify ScaleIO Configuration
 51 | 
 52 | It is important to determine the Master, Slave and TieBreaker MDM (Metadata Manager)
 53 | nodes, as this information is needed to launch the framework. Through multiple
 54 | testing scenarios, ScaleIONode2 (with the Private IP address of 10.0.0.12) is
 55 | typically the Primary MDM node. SSH into that instance using the Public DNS or IP
 56 | 
 57 | ```
 58 | ssh -i "keypair.pem" ec2-user@ScaleIONode2-IP-or-DNS
 59 | ```
 60 | 
 61 | Run the following commands:
 62 | 
 63 | 1. Log into the ScaleIO shell:
 64 |     ```
 65 | scli --login --username admin --password F00barbaz
 66 |     ```
 67 | 
 68 | 2. Verify the MDM nodes:
 69 |     ```
 70 | scli --query_cluster
 71 |     ```
 72 | 
 73 | Sample output will look like this:
 74 | ```
 75 | Cluster:
 76 |     Mode: 3_node, State: Normal, Active: 3/3, Replicas: 2/2
 77 | Master MDM:
 78 |     Name: Manager2, ID: 0x1ed68652078a0ab1
 79 |         IPs: 10.0.0.12, Management IPs: 10.0.0.12, Port: 9011
 80 |         Version: 2.0.5014
 81 | Slave MDMs:
 82 |     Name: Manager1, ID: 0x44691e69695396d0
 83 |         IPs: 10.0.0.11, Management IPs: 10.0.0.11, Port: 9011
 84 |         Status: Normal, Version: 2.0.5014
 85 | Tie-Breakers:
 86 |     Name: Tie-Breaker1, ID: 0x569bc3812558b2d2
 87 |         IPs: 10.0.0.13, Port: 9011
 88 |         Status: Normal, Version: 2.0.5014
 89 | ```
 90 | 
 91 | ### Launch Framework
 92 | 
 93 | Before launching, open the Marathon UI at:
 94 | ```
 95 | http://[MESOS MASTER PUBLIC DNS/IP ADDRESS]:8080
 96 | ```
 97 | 
 98 | Utilize [scaleio.json](scaleio.json) to correctly match and/or update the
 99 | internal IP addresses of the Master, Slave, and TieBreaker MDM nodes. Typically,
100 | but not always, the defaults are the correct values:
101 | 
102 | ```
103 | {
104 |   "id": "scaleio-scheduler",
105 |   "uris": [
106 |     "https://github.com/codedellemc/scaleio-framework/releases/download/v0.3.1/scaleio-scheduler",
107 |     "https://github.com/codedellemc/scaleio-framework/releases/download/v0.3.1/scaleio-executor"
108 |   ],
109 |   "cmd": "chmod u+x scaleio-scheduler && ./scaleio-scheduler -loglevel=debug -rest.port=$PORT -uri=10.0.0.21:5050 -scaleio.clusterid=6f831c6866417634 -scaleio.password=F00barbaz -scaleio.preconfig.primary=10.0.0.12 -scaleio.preconfig.secondary=10.0.0.11 -scaleio.preconfig.tiebreaker=10.0.0.13 -scaleio.preconfig.gateway=10.0.0.11",
110 |   "mem": 32,
111 |   "cpus": 0.2,
112 |   "instances": 1,
113 |   "constraints": [
114 |     ["hostname", "UNIQUE"]
115 |   ]
116 | }
117 | ```
118 | 
119 | After verifying the values are correct in the JSON file, cURL the JSON to
120 | Marathon by running the following command:
121 | ```
122 | curl -k -XPOST -d @scaleio.json -H "Content-Type: application/json" [MESOS MASTER PUBLIC DNS/IP ADDRESS]:8080/v2/apps
123 | ```
124 | 
125 | View the status of the ScaleIO framework by opening the Deployment UI.
126 | 
127 | 1. Within the Marathon UI at `http://[MESOS MASTER PUBLIC DNS/IP ADDRESS]:8080`, Click the `scaleio-scheduler`.
128 | 2. Underneath the scheduler's ID, click the link (circled in red below) to open up a simple installation status page contained within the scheduler.
129 | 3. A list Mesos Agent nodes with the current status of ScaleIO deployment can be seen and the page will automatically refresh itself.
130 | 
131 | ![Marathon Configuration](../images/marathon.png)
132 | ![Framework Status Page](../images/status.png)
133 | 
134 | **The Agent Nodes WILL REBOOT after successful installation**. This is done
135 | within this demo ONLY to make sure ScaleIO, Docker, REX-Ray and Marathon
136 | services are functioning properly. This process can take 2-5 minutes.
137 | 
138 | The status of ScaleIO deployment web portal will be restarted on the other
139 | Mesos Agent with a new port.
140 | 
141 | ### Deploy Applications
142 | 
143 | This particular setup has a 5 minute timeout. If a Docker image takes longer
144 | than 5 minutes to download, then deployment will fail. It's suggested to go to
145 | each Mesos Agent and download the image using `docker pull` if there is a poor
146 | connection.
147 | 
148 | ```
149 | $ ssh -i "keypair.pem" ubuntu@MesosAgent1_IP_or_DNS
150 | $ docker pull <image name>
151 | ```
152 | 
153 | Deploying Applications:
154 | 
155 | 1. [Storage Persistence with Postgres using Mesos, Marathon, Docker, and REX-Ray](https://github.com/codedellemc/demo/tree/master/demo-persistence-with-postgres-marathon-docker)
156 | 


--------------------------------------------------------------------------------
/.docs/user-guide/deployment-strategies.md:
--------------------------------------------------------------------------------
 1 | # Deployment Strategies
 2 | 
 3 | What deployment strategies does the Framework offer?
 4 | 
 5 | ---
 6 | 
 7 | ## Overview
 8 | This section describes the deployment options that are available via the
 9 | Framework. Depending on what your end game is, you might prefer to one method
10 | over the other. This guide will help you decide which option will best suit
11 | your needs.
12 | 
13 | ## Single Global Pool
14 | 
15 | I call this the "Just Make It Work" option. This is by far the easiest option to
16 | get working because it requires zero work, but the issue is that unless you give
17 | some thought in what resources are attached to what nodes, it may be difficult
18 | to get this method of deployment to adhere to [best practices](h15148-emc-scaleio-deployment-guide.pdf)
19 | for deploying ScaleIO.
20 | 
21 | When using this option, the Framework will create a single protection domain named
22 | **default** and a single storage pool named **default** (unless you override the
23 | values for -scaleio.protectiondomain and -scaleio.storagepool) out of any free
24 | device (ie does not have a filesystem) attached to every Mesos Agent node that
25 | is available.
26 | 
27 | It feels natural to just attach a disk (whether your on bare metal, in a virtualized
28 | environment, or in AWS, etc) to every Mesos Agent node in your Mesos cluster and
29 | call it a day. That configuration will give you a functioning ScaleIO cluster, but
30 | it may not follow best practices. For a demo or test environment, this is a great
31 | and simple configuration to deploy however. An example of how you might get this
32 | option to work in a production environment is to earmark certain nodes to have
33 | disks attached to certain Mesos Agent nodes (provides storage. these are the sds's)
34 | and have other Mesos Agent nodes without any disks (consumes storage. these are
35 | the sdc's).
36 | 
37 | ## Imperative Deployment
38 | 
39 | I call this the "Deploy It Exactly Like This" option. Using
40 | [Mesos Agent attributes](http://mesos.apache.org/documentation/latest/attributes-resources/),
41 | you can declare a precise configuration for every Mesos Agent node in your
42 | configuration.
43 | 
44 | To declare what disks contributes to what StoragePools and ProtectionDomains,
45 | the following Mesos Agent nodes attributes must be defined: scaleio-sds-domains,
46 | scaleio-sds-[domain], and scaleio-sds-[pool]. In the example below, the Mesos
47 | attributes create: 1) a protection domain named `mydomain` with storage pool named
48 | `mypool` consisting of the disk attached at `/dev/xvdf`, and 2) a second protection
49 | domain named `myotherdomain` with storage pools named `saltwaterpool` consisting of the
50 | disks attached at `/dev/xvdg` and `/dev/xvdh` and `freshwaterpool` consisting of the
51 | disk attached at `/dev/xvdi`.
52 | 
53 | ```
54 | # cat /etc/mesos-slave/attributes/scaleio-sds-domains
55 | mydomain,myotherdomain
56 | 
57 | #cat /etc/mesos-slave/attributes/scaleio-sds-mydomain
58 | mypool
59 | 
60 | # cat /etc/mesos-slave/attributes/scaleio-sds-myotherdomain
61 | saltwaterpool,freshwaterpool
62 | 
63 | # cat /etc/mesos-slave/attributes/scaleio-sds-mypool
64 | /dev/xvdf
65 | 
66 | # cat /etc/mesos-slave/attributes/scaleio-sds-saltwaterpool
67 | /dev/xvdg,/dev/xvdh
68 | 
69 | # cat /etc/mesos-slave/attributes/scaleio-sds-freshwaterpool
70 | /dev/xvdi
71 | ```
72 | 
73 | To declare what Mesos Agent nodes consume storage out of which
74 | ProtectionDomain/StoragePool combination, the following Mesos Agent nodes
75 | attributes must be defined: scaleio-sdc-domains and scaleio-sdc-[domain]. In the
76 | example below, the Mesos Agent node will consume/provision/etc volumes from the
77 | protection domain named `mydomain` and storage pool named `mypool`:
78 | 
79 | ```
80 | # cat /etc/mesos-slave/attributes/scaleio-sdc-domains
81 | mydomain
82 | 
83 | # cat /etc/mesos-slave/attributes/scaleio-sdc-mydomain1
84 | mypool
85 | ```
86 | 
87 | There is a limitation currently in [rexray](https://github.com/codedellemc/rexray)
88 | such that you can only consume/provision/etc a single ProtectionDomain/StoragePool
89 | combination. If no sdc attributes are defined, the first attribute pair from the
90 | sds attributes will be used. Else the default values based on the Configuration
91 | flags will be used (-scaleio.protectiondomain and
92 | -scaleio.storagepool).
93 | 
94 | ## Declarative Deployment
95 | 
96 | Coming Soon.
97 | 


--------------------------------------------------------------------------------
/.docs/user-guide/experimental.md:
--------------------------------------------------------------------------------
  1 | # Experimental
  2 | 
  3 | Yea, yea, yea... I know. I am pushing the envelope on this one.
  4 | 
  5 | ---
  6 | 
  7 | ## Overview
  8 | This section list functionality that exists that is in the experimental stage. You
  9 | don't want to be using these features in production unless you like to live
 10 | dangerously. I am talking like riding in the middle of the
 11 | [El Toro Y](https://en.wikipedia.org/wiki/El_Toro_Y) during rush hour on a
 12 | unicycle without a helmet while holding a pair of scissors. Just put it this way,
 13 | you are probably not likely to survive. Use these features at your own risk!
 14 | 
 15 | ## Provision the Entire ScaleIO Cluster
 16 | 
 17 | If you have read the documentation like I have, provision the entire ScaleIO
 18 | cluster can be quite complex. This Framework's intention has always been about
 19 | making that process and the monitoring of ScaleIO super easy. This is an early
 20 | look at that process which will provision the entire ScaleIO cluster from
 21 | scratch. That means starting from a bare Mesos cluster, the Framework will allow
 22 | you to stand up the 3 MDM (Primary, Secondary, and TieBreaker) nodes plus any
 23 | other data nodes without any existing ScaleIO infrastructure.
 24 | 
 25 | To use this functionality, you must have 3 Mesos Agent nodes with at least 4GB
 26 | of memory and 1.5 CPUs free and available for the MDM nodes. Currently, only the
 27 | 3 MDM nodes configuration is supported. Rhe 5 MDM node configuration will be
 28 | added at a later date. That means the minimum ScaleIO configuration would 3 nodes
 29 | where each of the 3 Agents nodes needs to meet the memory and CPU prerequisites,
 30 | have at least 180GB hard disks on each Agent node, and ScaleIO volumes can be
 31 | provisioned and consumed on those 3 Agent nodes.
 32 | 
 33 | To launch and provision the entire ScaleIO cluster, you can use the Marathon API
 34 | and cURL the following JSON:
 35 | 
 36 | ```
 37 | {
 38 |   "id": "scaleio-scheduler",
 39 |   "uris": [
 40 |     "https://github.com/codedellemc/scaleio-framework/releases/download/v0.3.1/scaleio-scheduler",
 41 |     "https://github.com/codedellemc/scaleio-framework/releases/download/v0.3.1/scaleio-executor"
 42 |   ],
 43 |   "cmd": "chmod u+x scaleio-scheduler && ./scaleio-scheduler -loglevel=debug -experimental=true -rest.port=$PORT -uri=[IP ADDRESS FOR ANY MESOS MASTER]:5050",
 44 |   "mem": 32,
 45 |   "cpus": 0.2,
 46 |   "instances": 1,
 47 |   "constraints": [
 48 |     ["hostname", "UNIQUE"]
 49 |   ]
 50 | }
 51 | ```
 52 | 
 53 | As you can see, as we start turning over more of the operation of ScaleIO to the
 54 | Framework, launching the Framework becomes even easier.
 55 | 
 56 | Now the bad news, the main reason why you wouldn't want to use this option in
 57 | production is that this currently will not automatically place the MDM nodes
 58 | into protection domains or in locations on the Mesos cluster that when nodes fail
 59 | the ScaleIO MDM nodes can tolerate fault and continue to function without
 60 | interruption. The above example works for the Single Global Pool
 61 | [deployment option](/user-guide/deployment-strategies.md) and it *might* meet your
 62 | needs. There is functionality to use the Imperative Deployment where you can
 63 | declare before launching the Framework where you want the Primary, Secondary,
 64 | and TieBreaker nodes to get installed on; meaning you can place these nodes based
 65 | on a plan to handle fault tolerance. For example, each MDM node can be chosen to
 66 | get installed in their own unique racks. For more information on that option,
 67 | please contact us directly in the
 68 | [{code} community slack](http://community.codedellemc.com/).
 69 | 
 70 | ## Self Remediating Functionality in the Cloud
 71 | 
 72 | This is a preview feature for the ScaleIO Framework which starts to pave the way
 73 | of the real value add for what this project really intends to provide. This
 74 | feature only currently supports AWS environments but can be expanded to support
 75 | additional clouds (like GCE, DigitalOcean, etc) in the future. When this
 76 | feature is enabled (disabled by default), the Framework will monitor the Storage
 77 | Pools to see if they are starting to fill up and reach its maximum capacity. This
 78 | can happen especially when you provision your ScaleIO volumes to be thin provisioned
 79 | (ie allow the volume to grow to its max capacity on demand).
 80 | 
 81 | When the Storage Pool starts to reach full, the Framework will detect the event
 82 | and create additional EBS volumes, attach them to the Mesos Agent nodes, and add
 83 | them to the Storage Pool thus expanding its maximum capacity. Features like this
 84 | will be added in the near future and this feature will continue to be refined
 85 | going forward.
 86 | 
 87 | To enable this feature in AWS clouds, you will need to provide an IAM access and
 88 | secret key that has the following
 89 | [permissions](http://libstorage.readthedocs.io/en/stable/user-guide/storage-providers/#aws-ebs)
 90 | in order to provision and use these EBS volumes. If we then wanted to provision
 91 | the entire ScaleIO cluster using the above feature and enable this Self
 92 | Remediating Cloud functionality, you can use the Marathon API and cURL the
 93 | following JSON:
 94 | 
 95 | ```
 96 | {
 97 |   "id": "scaleio-scheduler",
 98 |   "uris": [
 99 |     "https://github.com/codedellemc/scaleio-framework/releases/download/v0.3.1/scaleio-scheduler",
100 |     "https://github.com/codedellemc/scaleio-framework/releases/download/v0.3.1/scaleio-executor"
101 |   ],
102 |   "cmd": "chmod u+x scaleio-scheduler && ./scaleio-scheduler -loglevel=debug -experimental=true -rest.port=$PORT -uri=[IP ADDRESS FOR ANY MESOS MASTER]:5050 -aws.accesskey=[ACCESS KEY] -aws.secretkey=[SECRET KEY]",
103 |   "mem": 32,
104 |   "cpus": 0.2,
105 |   "instances": 1,
106 |   "constraints": [
107 |     ["hostname", "UNIQUE"]
108 |   ]
109 | }
110 | ```
111 | 


--------------------------------------------------------------------------------
/.docs/user-guide/h15148-emc-scaleio-deployment-guide.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thecodeteam/scaleio-framework/3fb79e9a2a1a130ca0fd201678a9fbaf92243d0e/.docs/user-guide/h15148-emc-scaleio-deployment-guide.pdf


--------------------------------------------------------------------------------
/.docs/user-guide/installation.md:
--------------------------------------------------------------------------------
  1 | # Installation
  2 | 
  3 | How do I install this?
  4 | 
  5 | ---
  6 | 
  7 | ## Overview
  8 | ScaleIO-Framework is written in Go, so there are typically no dependencies that
  9 | must be installed alongside its single binary file. The Framework is deployed
 10 | via [Marathon](https://mesosphere.github.io/marathon/).
 11 | 
 12 | ## Requirements
 13 | - Ubuntu 14.04 or CentOS7/RHEL7
 14 | - Since Ubuntu 14.04 support for ScaleIO is limited, this framework currently only supports ScaleIO version 2.0.1-2072 and kernel linux-image-4.4.0-38-generic. You can run `apt-get -y update && apt-get -y install linux-image-4.4.0-38-generic` for install that version.
 15 | - An **existing** 3-node or greater ScaleIO cluster using version 2.0.1-2072 must be running/provided. Primary, Secondary, and TieBreaker MDM are required for a minimal 3-node cluster.
 16 | - The ScaleIO cluster must have a Protection Domain and Storage Pool present which is capable of provisioning volumes.
 17 | - This Framework is implemented using HTTP APIs provided by Apache Mesos. This requires an Apache Mesos cluster running version 1.0 or higher with a compatible version of Marathon installed.
 18 | 
 19 | ## Deployment Strategies
 20 | Before you deploy the Framework, you might want to think about what you want your
 21 | final fully deployed ScaleIO cluster to look like. Please take a look at the
 22 | [Deployment Strategies](/user-guide/deployment-strategies.md) section to
 23 | determine the best method for deploying your desired configuration.
 24 | 
 25 | ## Deploying the latest version
 26 | 
 27 | The easiest way to deploy the latest version of the ScaleIO Framework is to
 28 | `curl` the [JSON file](sioframework-latest.json) below representing a task to
 29 | Marathon.
 30 | 
 31 | Before issuing the `curl` command, there are a couple of placeholder variables
 32 | you need to replace with real values. Those placeholders are enclosed in brackets.
 33 | 
 34 | ```
 35 | {
 36 |   "id": "scaleio-scheduler",
 37 |   "uris": [
 38 |     "https://github.com/codedellemc/scaleio-framework/releases/download/v0.3.1/scaleio-scheduler",
 39 |     "https://github.com/codedellemc/scaleio-framework/releases/download/v0.3.1/scaleio-executor"
 40 |   ],
 41 |   "cmd": "chmod u+x scaleio-scheduler && ./scaleio-scheduler -loglevel=debug -rest.port=$PORT -uri=[IP ADDRESS FOR ANY MESOS MASTER]:5050 -scaleio.password=[SCALEIO GATEWAY PASSWORD] -scaleio.protectiondomain=[PROTECTION DOMAIN NAME] -scaleio.storagepool=[STORAGE POOL NAME] -scaleio.preconfig.primary=[MASTER MDM IP ADDRESS] -scaleio.preconfig.secondary=[SLAVE MDM IP ADDRESS] -scaleio.preconfig.tiebreaker=[TIEBREAKER MDM IP ADDRESS] -scaleio.preconfig.gateway=[GATEWAY IP ADDRESS]",
 42 |   "mem": 32,
 43 |   "cpus": 0.2,
 44 |   "instances": 1,
 45 |   "constraints": [
 46 |     ["hostname", "UNIQUE"]
 47 |   ]
 48 | }
 49 | ```
 50 | 
 51 | Once those values have been replaced, issues the `curl` command like so:
 52 | ```
 53 | curl -k -XPOST -d @sioframework-latest.json -H "Content-Type: application/json" [MARATHON IP ADDRESS]:8080/v2/apps
 54 | ```
 55 | 
 56 | ## Deploying a specific release
 57 | 
 58 | To deploy a specific version of the ScaleIO Framework we use a similar
 59 | `curl` command with a slightly modified version of the [JSON file](sioframework-v020.json)
 60 | to Marathon.
 61 | 
 62 | Before issuing the `curl` command, we need to fill in the placeholder variables
 63 | like before.
 64 | 
 65 | ```
 66 | {
 67 |   "id": "scaleio-scheduler",
 68 |   "uris": [
 69 |     "https://github.com/codedellemc/scaleio-framework/releases/download/v0.3.1/scaleio-scheduler",
 70 |     "https://github.com/codedellemc/scaleio-framework/releases/download/v0.3.1/scaleio-executor"
 71 |   ],
 72 |   "cmd": "chmod u+x scaleio-scheduler && ./scaleio-scheduler -loglevel=debug -rest.port=$PORT -uri=[IP ADDRESS FOR ANY MESOS MASTER]:5050 -scaleio.password=[SCALEIO GATEWAY PASSWORD] -scaleio.protectiondomain=[PROTECTION DOMAIN NAME] -scaleio.storagepool=[STORAGE POOL NAME] -scaleio.preconfig.primary=[MASTER MDM IP ADDRESS] -scaleio.preconfig.secondary=[SLAVE MDM IP ADDRESS] -scaleio.preconfig.tiebreaker=[TIEBREAKER MDM IP ADDRESS] -scaleio.preconfig.gateway=[GATEWAY IP ADDRESS]",
 73 |   "mem": 32,
 74 |   "cpus": 0.2,
 75 |   "instances": 1,
 76 |   "constraints": [
 77 |     ["hostname", "UNIQUE"]
 78 |   ]
 79 | }
 80 | ```
 81 | 
 82 | Once those values have been replaced, issues the `curl` command like so:
 83 | ```
 84 | curl -k -XPOST -d @sioframework-v020.json -H "Content-Type: application/json" [MARATHON IP ADDRESS]:8080/v2/apps
 85 | ```
 86 | 
 87 | ## Build and install from source
 88 | 
 89 | The `ScaleIO-Framework` is also fairly simple to build from source. For more
 90 | information, please visit the [build-reference](/developer-guide/build-reference.md)
 91 | for more details.
 92 | 
 93 | To deploy a build from source, you will need access to an HTTP server in which
 94 | you can house the scaleio-scheduler and scaleio-executor for Marathon to download
 95 | from. After you have placed your custom build binaries, you can make the following
 96 | modification to the JSON file to deploy the Framework (replace `your.domain/path/to/your`
 97 | with the http location of your binaries):
 98 | 
 99 | ```
100 | {
101 |   "id": "scaleio-scheduler",
102 |   "uris": [
103 |     "https://your.domain/path/to/your/scaleio-scheduler",
104 |     "https://your.domain/path/to/your/scaleio-executor"
105 |   ],
106 |   "cmd": "chmod u+x scaleio-scheduler && ./scaleio-scheduler -loglevel=debug -rest.port=$PORT -uri=[IP ADDRESS FOR ANY MESOS MASTER]:5050 -scaleio.password=[SCALEIO GATEWAY PASSWORD] -scaleio.protectiondomain=[PROTECTION DOMAIN NAME] -scaleio.storagepool=[STORAGE POOL NAME] -scaleio.preconfig.primary=[MASTER MDM IP ADDRESS] -scaleio.preconfig.secondary=[SLAVE MDM IP ADDRESS] -scaleio.preconfig.tiebreaker=[TIEBREAKER MDM IP ADDRESS] -scaleio.preconfig.gateway=[GATEWAY IP ADDRESS]",
107 |   "mem": 32,
108 |   "cpus": 0.2,
109 |   "instances": 1,
110 |   "constraints": [
111 |     ["hostname", "UNIQUE"]
112 |   ]
113 | }
114 | ```
115 | 
116 | ## (Experimental) Provision the Entire ScaleIO Cluster
117 | 
118 | There exist an experimental feature to provision the entire ScaleIO cluster from
119 | scratch which includes the 3 MDM (Primary, Secondary, and TieBreaker) nodes. This
120 | will allow you to stand up ScaleIO on a bare Mesos cluster without any existing
121 | ScaleIO infrastructure.
122 | 
123 | For more information, please visit the [experimental](/user-guide/experimental.md)
124 | page for more details.
125 | 


--------------------------------------------------------------------------------
/.docs/user-guide/scaleio.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "id": "scaleio-scheduler",
 3 |   "uris": [
 4 |     "https://github.com/codedellemc/scaleio-framework/releases/download/v0.3.1/scaleio-scheduler",
 5 |     "https://github.com/codedellemc/scaleio-framework/releases/download/v0.3.1/scaleio-executor"
 6 |   ],
 7 |   "cmd": "chmod u+x scaleio-scheduler && ./scaleio-scheduler -loglevel=debug -rest.port=$PORT -uri=10.0.0.21:5050 -scaleio.clusterid=6f831c6866417634 -scaleio.password=F00barbaz -scaleio.protectiondomain=default -scaleio.storagepool=default -scaleio.preconfig.primary=10.0.0.12 -scaleio.preconfig.secondary=10.0.0.11 -scaleio.preconfig.tiebreaker=10.0.0.13 -scaleio.preconfig.gateway=10.0.0.11",
 8 |   "mem": 32,
 9 |   "cpus": 0.2,
10 |   "instances": 1,
11 |   "constraints": [
12 |     ["hostname", "UNIQUE"]
13 |   ]
14 | }
15 | 


--------------------------------------------------------------------------------
/.docs/user-guide/sioframework-latest.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "id": "scaleio-scheduler",
 3 |   "uris": [
 4 |     "https://github.com/codedellemc/scaleio-framework/releases/download/v0.3.1/scaleio-scheduler",
 5 |     "https://github.com/codedellemc/scaleio-framework/releases/download/v0.3.1/scaleio-executor"
 6 |   ],
 7 |   "cmd": "chmod u+x scaleio-scheduler && ./scaleio-scheduler -loglevel=debug -rest.port=$PORT -uri=[IP ADDRESS FOR MESOS MASTER]:5050 -scaleio.password=[SCALEIO GATEWAY PASSWORD] -scaleio.protectiondomain=[PROTECTION DOMAIN NAME] -scaleio.storagepool=[STORAGE POOL NAME] -scaleio.preconfig.primary=[MASTER MDM IP ADDRESS] -scaleio.preconfig.secondary=[SLAVE MDM IP ADDRESS] -scaleio.preconfig.tiebreaker=[TIEBREAKER MDM IP ADDRESS] -scaleio.preconfig.gateway=[GATEWAY IP ADDRESS]",
 8 |   "mem": 32,
 9 |   "cpus": 0.2,
10 |   "instances": 1,
11 |   "constraints": [
12 |     ["hostname", "UNIQUE"]
13 |   ]
14 | }
15 | 


--------------------------------------------------------------------------------
/.docs/user-guide/sioframework-v020.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "id": "scaleio-scheduler",
 3 |   "uris": [
 4 |     "https://github.com/codedellemc/scaleio-framework/releases/download/v0.2.0/scaleio-scheduler",
 5 |     "https://github.com/codedellemc/scaleio-framework/releases/download/v0.2.0/scaleio-executor"
 6 |   ],
 7 |   "cmd": "chmod u+x scaleio-scheduler && ./scaleio-scheduler -loglevel=debug -rest.port=$PORT -uri=[IP ADDRESS FOR ANY MESOS MASTER]:5050 -scaleio.password=[SCALEIO GATEWAY PASSWORD] -scaleio.protectiondomain=[PROTECTION DOMAIN NAME] -scaleio.storagepool=[STORAGE POOL NAME] -scaleio.preconfig.primary=[MASTER MDM IP ADDRESS] -scaleio.preconfig.secondary=[SLAVE MDM IP ADDRESS] -scaleio.preconfig.tiebreaker=[TIEBREAKER MDM IP ADDRESS] -scaleio.preconfig.gateway=[GATEWAY IP ADDRESS]",
 8 |   "mem": 32,
 9 |   "cpus": 0.2,
10 |   "instances": 1,
11 |   "constraints": [
12 |     ["hostname", "UNIQUE"]
13 |   ]
14 | }
15 | 


--------------------------------------------------------------------------------
/.docs/user-guide/troubleshooting.md:
--------------------------------------------------------------------------------
 1 | # Troubleshooting
 2 | 
 3 | I need help!
 4 | 
 5 | ---
 6 | 
 7 | ## Log file location
 8 | 
 9 | ScaleIO-Framework keeps a log in the `stdout` file for the Marathon's task.
10 | 
11 | ## Debug output
12 | 
13 | The ScaleIO-Framework can be started with the `-debug=true` flag to maximize log
14 | detail.
15 | 
16 | To watch polly live, including error output and traces, you simply open the
17 | `stdout` files on the Marathon task. A new window with the streaming output for
18 | the `stdout` will be created.
19 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .vagrant/
2 | .DS_Store
3 | glide.lock
4 | scaleio-executor/scaleio-executor
5 | scaleio-scheduler/scaleio-scheduler
6 | scaleio-scheduler/vendor/
7 | scaleio-executor/vendor/
8 | .build/
9 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # ScaleIO Framework for Apache Mesos
 2 | 
 3 | ![logo](img/logo.png)
 4 | 
 5 | The ScaleIO Framework deploys Dell EMC ScaleIO as a simplified task in Apache Mesos. All the required components to consume and provision storage volumes from a ScaleIO cluster are automatically deployed and configured on the Mesos Agents. This creates an automated mechanism to have a fully configured and reliable persistent storage solution for containers running on Apache Mesos.
 6 | 
 7 | ## Key Features
 8 | - Installs required components on existing Mesos Agents to consume and provision ScaleIO storage volumes
 9 | - On-boards new Agent nodes with *"native"* access to ScaleIO volumes
10 | - All Agent nodes are configured to be highly available so failed applications can be restarted on other Agent nodes while preserving their data using [REX-Ray](https://github.com/emccode/rexray) as a container runtime volume driver
11 | - Additional storage can be added to the ScaleIO cluster to expand capacity
12 | 
13 | ## What it does
14 | Container runtime schedulers need to be integrated with every aspect of available hardware resources, including persistent storage. When requesting resources for an application the scheduler gets offers for CPU, RAM and disk.
15 | 
16 | To be able to offer persistent storage in a scalable way, the ScaleIO Framework installs and configures all necessary ScaleIO, a Software-based Storage Platform, components along with all the "glue" to connect Mesos and ScaleIO to service applications requiring persistent storage.
17 | 
18 | ## Documentation [![Docs](https://readthedocs.org/projects/scaleio-framework/badge/?version=stable)](http://scaleio-framework.readthedocs.org/en/stable/)
19 | You will find complete documentation for ScaleIO-Framework at [scaleio-framework.readthedocs.org](http://scaleio-framework.readthedocs.org/en/stable/), including
20 | [licensing](http://scaleio-framework.readthedocs.org/en/stable/about/license/) and
21 | [support](http://scaleio-framework.readthedocs.org/en/stable/#getting-help) information.
22 | Documentation provided at RTD is based on the latest stable build. The `/.docs`
23 | directory in this repo will refer to the latest or specific commit.
24 | 
25 | ## Road map / TBDs
26 | The current release highlights the capabilities of combining Software Defined Storage with a platform that offers 2-layer scheduling. Subsequent versions will add significantly more features.
27 | 
28 | - Add CoreOS support
29 | - Add ability to provision an entire ScaleIO cluster and include the MDM management nodes from initialization
30 | - Allow more customization of the ScaleIO deployment
31 | - Manage entire life cycle (upgrades, maintenance, etc) of all nodes in the ScaleIO cluster
32 | - Manages health of a ScaleIO cluster by monitoring for critical events (Performance, Almost Full, etc)
33 | 
34 | ## Support
35 | Please file bugs and issues on the Github issues page for this project. This is to help keep track and document everything related to this repo. For general discussions and further support,  join the [{code} by Dell EMC Community](http://community.codedellemc.com/) slack team. The code and documentation are released with no warranties or SLAs and are intended to be supported through a community driven process.
36 | 


--------------------------------------------------------------------------------
/VERSION:
--------------------------------------------------------------------------------
1 | 0.3.1
2 | 


--------------------------------------------------------------------------------
/img/icon-large.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thecodeteam/scaleio-framework/3fb79e9a2a1a130ca0fd201678a9fbaf92243d0e/img/icon-large.png


--------------------------------------------------------------------------------
/img/icon-medium.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thecodeteam/scaleio-framework/3fb79e9a2a1a130ca0fd201678a9fbaf92243d0e/img/icon-medium.png


--------------------------------------------------------------------------------
/img/icon-small.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thecodeteam/scaleio-framework/3fb79e9a2a1a130ca0fd201678a9fbaf92243d0e/img/icon-small.png


--------------------------------------------------------------------------------
/img/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thecodeteam/scaleio-framework/3fb79e9a2a1a130ca0fd201678a9fbaf92243d0e/img/logo.png


--------------------------------------------------------------------------------
/img/logo.psd:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thecodeteam/scaleio-framework/3fb79e9a2a1a130ca0fd201678a9fbaf92243d0e/img/logo.psd


--------------------------------------------------------------------------------
/mkdocs.yml:
--------------------------------------------------------------------------------
 1 | site_name: ScaleIO-Framework
 2 | site_url: https://github.com/codedellemc/scaleio-framework
 3 | repo_url: https://github.com/codedellemc/scaleio-framework.git
 4 | docs_dir: .docs
 5 | site_dir: .site
 6 | theme_dir: .docs/.themes/yeti
 7 | #site_favicon: favicon.png
 8 | 
 9 | pages:
10 | - Home: index.md
11 | - User Guide:
12 |     - Installation: user-guide/installation.md
13 |     - Configuration: user-guide/configuration.md
14 |     - Deployment Strategies: user-guide/deployment-strategies.md
15 |     - Demo: user-guide/demo.md
16 |     - Troubleshooting: user-guide/troubleshooting.md
17 |     - Experimental: user-guide/experimental.md
18 | - Developer guide:
19 |     - Project guidelines: developer-guide/project-guidelines.md
20 |     - REST API: developer-guide/restapi.md
21 |     - Build reference: developer-guide/build-reference.md
22 |     - Release process: developer-guide/release-process.md
23 | - About:
24 |     - Contributing: about/contributing.md
25 |     - License: about/license.md
26 |     - Release notes: about/release-notes.md
27 | 


--------------------------------------------------------------------------------
/scaleio-executor/build.sh:
--------------------------------------------------------------------------------
 1 | #! /usr/bin/env bash
 2 | 
 3 | rm -rf ./vendor
 4 | rm glide.lock
 5 | rm ./scaleio-executor
 6 | glide up
 7 | 
 8 | grep -R --exclude-dir vendor --exclude-dir .git --exclude-dir mesos --exclude build.sh TODO ./
 9 | 
10 | GOOS=linux GOARCH=amd64 go build .
11 | 


--------------------------------------------------------------------------------
/scaleio-executor/client/http.go:
--------------------------------------------------------------------------------
 1 | package client
 2 | 
 3 | import (
 4 | 	"bytes"
 5 | 	"net"
 6 | 	"net/http"
 7 | 	"time"
 8 | 
 9 | 	log "github.com/Sirupsen/logrus"
10 | )
11 | 
12 | const (
13 | 	defaultReadTimeout  = 10 * time.Second
14 | 	defaultWriteTimeout = 10 * time.Second
15 | )
16 | 
17 | //Client representation of an HTTP client
18 | type Client struct {
19 | 	streamID string
20 | 	url      string
21 | 	client   *http.Client
22 | }
23 | 
24 | //New generates a new HTTP client
25 | func New(addr string, path string) *Client {
26 | 	return &Client{
27 | 		url: "http://" + addr + path,
28 | 		client: &http.Client{
29 | 			Transport: &http.Transport{
30 | 				Dial: (&net.Dialer{
31 | 					Timeout:   10 * time.Second,
32 | 					KeepAlive: 30 * time.Second,
33 | 				}).Dial,
34 | 			},
35 | 		},
36 | 	}
37 | }
38 | 
39 | //Send will send a HTTP payload to an HTTP server
40 | func (c *Client) Send(payload []byte) (*http.Response, error) {
41 | 	httpReq, err := http.NewRequest("POST", c.url, bytes.NewReader(payload))
42 | 	if err != nil {
43 | 		return nil, err
44 | 	}
45 | 
46 | 	httpReq.Header.Set("Content-Type", "application/x-protobuf")
47 | 	httpReq.Header.Set("Accept", "application/json") //TODO switch to protobuf at some point
48 | 	httpReq.Header.Set("User-Agent", "scaleio/0.1")
49 | 	if c.streamID != "" {
50 | 		httpReq.Header.Set("Mesos-Stream-Id", c.streamID)
51 | 	}
52 | 
53 | 	httpResp, err := c.client.Do(httpReq)
54 | 	if err != nil {
55 | 		log.Errorln("HTTP ERROR:", err)
56 | 		return nil, err
57 | 	}
58 | 
59 | 	streamID := httpResp.Header.Get("Mesos-Stream-Id")
60 | 	if streamID != "" {
61 | 		if c.streamID == "" {
62 | 			log.Infoln("[MESOS-STREAM-ID] Setting to", streamID)
63 | 		} else {
64 | 			log.Infoln("[MESOS-STREAM-ID]", c.streamID, "->", streamID)
65 | 		}
66 | 		c.streamID = streamID
67 | 	}
68 | 	return httpResp, nil
69 | }
70 | 


--------------------------------------------------------------------------------
/scaleio-executor/config/config.go:
--------------------------------------------------------------------------------
 1 | package config
 2 | 
 3 | import (
 4 | 	"errors"
 5 | 	"flag"
 6 | 
 7 | 	xplatform "github.com/dvonthenen/goxplatform"
 8 | )
 9 | 
10 | var (
11 | 	//ErrInvalidRestURI The REST URI provided is not valid
12 | 	ErrInvalidRestURI = errors.New("The REST URI provided is not valid")
13 | )
14 | 
15 | //Config is the representation of the config
16 | type Config struct {
17 | 	LogLevel     string
18 | 	SchedulerURI string
19 | 	MesosAgent   string
20 | 	FrameworkID  string
21 | 	ExecutorID   string
22 | }
23 | 
24 | //AddFlags adds flags to the command line parsing
25 | func (cfg *Config) AddFlags(fs *flag.FlagSet) {
26 | 	fs.StringVar(&cfg.LogLevel, "loglevel", cfg.LogLevel,
27 | 		"Set the logging level for the application")
28 | 	fs.StringVar(&cfg.SchedulerURI, "rest.uri", cfg.SchedulerURI,
29 | 		"Scheduler REST API URI")
30 | 
31 | 	fs.StringVar(&cfg.MesosAgent, "mesos.agent", cfg.MesosAgent,
32 | 		"Mesos Agent address")
33 | 	fs.StringVar(&cfg.FrameworkID, "framework.id", cfg.FrameworkID,
34 | 		"Framework ID")
35 | 	fs.StringVar(&cfg.ExecutorID, "executor.id", cfg.ExecutorID,
36 | 		"Executor ID")
37 | }
38 | 
39 | //NewConfig creates a new Config object
40 | func NewConfig() *Config {
41 | 	return &Config{
42 | 		LogLevel:     env("LOG_LEVEL", "info"),
43 | 		SchedulerURI: env("SCHEDULER_URI", "127.0.0.1"),
44 | 		MesosAgent:   env("MESOS_AGENT_ENDPOINT", "127.0.0.1"),
45 | 		FrameworkID:  env("MESOS_FRAMEWORK_ID", ""),
46 | 		ExecutorID:   env("MESOS_EXECUTOR_ID", ""),
47 | 	}
48 | }
49 | 
50 | //ParseIPFromRestURI returns the IP from the URI
51 | func (cfg *Config) ParseIPFromRestURI() (string, error) {
52 | 	strings, err := xplatform.GetInstance().Str.RegexMatch(cfg.SchedulerURI, ".+//(.*):[0-9]+")
53 | 	if err != nil {
54 | 		return "", err
55 | 	}
56 | 	if len(strings) != 2 {
57 | 		return "", ErrInvalidRestURI
58 | 	}
59 | 	ip := strings[1]
60 | 	return ip, nil
61 | }
62 | 


--------------------------------------------------------------------------------
/scaleio-executor/config/env.go:
--------------------------------------------------------------------------------
 1 | package config
 2 | 
 3 | import (
 4 | 	"os"
 5 | 	"strconv"
 6 | 	"time"
 7 | )
 8 | 
 9 | func env(key, defaultValue string) (value string) {
10 | 	if value = os.Getenv(key); value == "" {
11 | 		value = defaultValue
12 | 	}
13 | 	return
14 | }
15 | 
16 | func envInt(key, defaultValue string) int {
17 | 	value, err := strconv.Atoi(env(key, defaultValue))
18 | 	if err != nil {
19 | 		panic(err.Error())
20 | 	}
21 | 	return value
22 | }
23 | 
24 | func envDuration(key, defaultValue string) time.Duration {
25 | 	value, err := time.ParseDuration(env(key, defaultValue))
26 | 	if err != nil {
27 | 		panic(err.Error())
28 | 	}
29 | 	return value
30 | }
31 | 
32 | func envFloat(key, defaultValue string) float64 {
33 | 	value, err := strconv.ParseFloat(env(key, defaultValue), 64)
34 | 	if err != nil {
35 | 		panic(err.Error())
36 | 	}
37 | 	return value
38 | }
39 | 


--------------------------------------------------------------------------------
/scaleio-executor/executor/common/common.go:
--------------------------------------------------------------------------------
  1 | package common
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 
  6 | 	log "github.com/Sirupsen/logrus"
  7 | 
  8 | 	types "github.com/codedellemc/scaleio-framework/scaleio-scheduler/types"
  9 | )
 10 | 
 11 | const (
 12 | 	//RebootCmdline reboot now
 13 | 	RebootCmdline = "shutdown -r now"
 14 | 
 15 | 	//RebootCheck check for the reboot
 16 | 	RebootCheck = "reboot in 1 minute"
 17 | )
 18 | 
 19 | var (
 20 | 	//ErrInitialStateFailed failed to get the initial state
 21 | 	ErrInitialStateFailed = errors.New("Failed to get the initial cluster state")
 22 | 
 23 | 	//ErrFindNodeFailed failed to find MDM Pair
 24 | 	ErrFindNodeFailed = errors.New("Failed to find the specific node")
 25 | 
 26 | 	//ErrMdmPairFailed failed to find MDM Pair
 27 | 	ErrMdmPairFailed = errors.New("Failed to Find MDM Pair")
 28 | 
 29 | 	//ErrStateChangeNotAcknowledged failed to find MDM Pair
 30 | 	ErrStateChangeNotAcknowledged = errors.New("The node state change was not acknowledged")
 31 | )
 32 | 
 33 | //PersonaStringToID String -> PersonaID
 34 | func PersonaStringToID(persona string) int {
 35 | 	switch persona {
 36 | 	case "primary":
 37 | 		return types.PersonaMdmPrimary
 38 | 	case "secondary":
 39 | 		return types.PersonaMdmSecondary
 40 | 	case "tiebreaker":
 41 | 		return types.PersonaTb
 42 | 	case "data":
 43 | 		return types.PersonaNode
 44 | 	default:
 45 | 		return types.PersonaUnknown
 46 | 	}
 47 | }
 48 | 
 49 | //PersonaIDToString PersonaID -> String
 50 | func PersonaIDToString(persona int) string {
 51 | 	switch persona {
 52 | 	case types.PersonaMdmPrimary:
 53 | 		return "primary"
 54 | 	case types.PersonaMdmSecondary:
 55 | 		return "secondary"
 56 | 	case types.PersonaTb:
 57 | 		return "tiebreaker"
 58 | 	case types.PersonaNode:
 59 | 		return "data"
 60 | 	default:
 61 | 		return "unknown"
 62 | 	}
 63 | }
 64 | 
 65 | //GetSelfNode gets self
 66 | func GetSelfNode(state *types.ScaleIOFramework, executorID string) *types.ScaleIONode {
 67 | 	log.Infoln("getSelfNode ENTER")
 68 | 	for _, node := range state.ScaleIO.Nodes {
 69 | 		if executorID == node.ExecutorID {
 70 | 			log.Infoln("getSelfNode Found:", node.ExecutorID)
 71 | 			log.Infoln("getSelfNode LEAVE")
 72 | 			return node
 73 | 		}
 74 | 	}
 75 | 	log.Infoln("getSelfNode NOT FOUND")
 76 | 	log.Infoln("getSelfNode LEAVE")
 77 | 	return nil
 78 | }
 79 | 
 80 | func getNodeType(state *types.ScaleIOFramework, nodeType int) (*types.ScaleIONode, error) {
 81 | 	for _, node := range state.ScaleIO.Nodes {
 82 | 		if node.Persona == nodeType {
 83 | 			log.Infoln("Found MDM Node:", node.ExecutorID, "Persona:", node.Persona)
 84 | 			return node, nil
 85 | 		}
 86 | 	}
 87 | 	return nil, ErrFindNodeFailed
 88 | }
 89 | 
 90 | //GetPrimaryMdmNode gets the Primary node
 91 | func GetPrimaryMdmNode(state *types.ScaleIOFramework) (*types.ScaleIONode, error) {
 92 | 	return getNodeType(state, types.PersonaMdmPrimary)
 93 | }
 94 | 
 95 | //GetSecondaryMdmNode gets the Secondary node
 96 | func GetSecondaryMdmNode(state *types.ScaleIOFramework) (*types.ScaleIONode, error) {
 97 | 	return getNodeType(state, types.PersonaMdmSecondary)
 98 | }
 99 | 
100 | //GetTiebreakerMdmNode gets the TB node
101 | func GetTiebreakerMdmNode(state *types.ScaleIOFramework) (*types.ScaleIONode, error) {
102 | 	return getNodeType(state, types.PersonaTb)
103 | }
104 | 
105 | func getMdmNodes(state *types.ScaleIOFramework) ([]types.ScaleIONode, error) {
106 | 	log.Infoln("getMdmNodes ENTER")
107 | 
108 | 	pri, err := GetPrimaryMdmNode(state)
109 | 	if err != nil {
110 | 		log.Infoln("Failed to find Primary MDM")
111 | 		log.Infoln("getMdmNodes LEAVE")
112 | 		return nil, ErrMdmPairFailed
113 | 	}
114 | 
115 | 	sec, err := GetSecondaryMdmNode(state)
116 | 	if err != nil {
117 | 		log.Infoln("Failed to find Secondary MDM")
118 | 		log.Infoln("getMdmNodes LEAVE")
119 | 		return nil, ErrMdmPairFailed
120 | 	}
121 | 
122 | 	var col []types.ScaleIONode
123 | 	col = append(col, *pri)
124 | 	col = append(col, *sec)
125 | 
126 | 	log.Infoln("Found MDM Pair")
127 | 	log.Infoln("getMdmNodes LEAVE")
128 | 	return col, nil
129 | }
130 | 
131 | //CreateMdmPairString just like it sounds
132 | func CreateMdmPairString(state *types.ScaleIOFramework) (string, error) {
133 | 	//use pre-configured MDM nodes
134 | 	if state.ScaleIO.Preconfig.PreConfigEnabled {
135 | 		str := state.ScaleIO.Preconfig.PrimaryMdmAddress + "," +
136 | 			state.ScaleIO.Preconfig.SecondaryMdmAddress
137 | 		log.Debugln("Using Pre-Configured MDMs:", str)
138 | 		return str, nil
139 | 	}
140 | 
141 | 	log.Debugln("Creating MDMs based on Configuration")
142 | 
143 | 	nodes, err := getMdmNodes(state)
144 | 	if err != nil {
145 | 		return "", err
146 | 	}
147 | 
148 | 	str := ""
149 | 	for _, node := range nodes {
150 | 		if len(str) > 0 {
151 | 			str += ","
152 | 		}
153 | 		str += node.IPAddress
154 | 	}
155 | 
156 | 	log.Debugln("IP String:", str)
157 | 	return str, nil
158 | }
159 | 
160 | //GenerateSdsName creates the SDS name for this given node
161 | func GenerateSdsName(node *types.ScaleIONode) string {
162 | 	str := "sds-" + node.Hostname
163 | 	return str
164 | }
165 | 
166 | //GetGatewayAddress returns the ScaleIO gateway address
167 | func GetGatewayAddress(state *types.ScaleIOFramework) (string, error) {
168 | 	if state.ScaleIO.Preconfig.PreConfigEnabled &&
169 | 		state.ScaleIO.Preconfig.GatewayAddress != "" {
170 | 		log.Debugln("Using Pre-Configured Gateway:",
171 | 			state.ScaleIO.Preconfig.GatewayAddress)
172 | 		return state.ScaleIO.Preconfig.GatewayAddress, nil
173 | 	} else if state.ScaleIO.Preconfig.PreConfigEnabled {
174 | 		log.Debugln("Pre-Configured Gateway Not Set:",
175 | 			state.ScaleIO.Preconfig.PrimaryMdmAddress)
176 | 		return state.ScaleIO.Preconfig.PrimaryMdmAddress, nil
177 | 	} else if state.ScaleIO.LbGateway != "" {
178 | 		log.Debugln("Using Load Balancing Gateway:",
179 | 			state.ScaleIO.LbGateway)
180 | 		return state.ScaleIO.LbGateway, nil
181 | 	}
182 | 
183 | 	pri, err := GetPrimaryMdmNode(state)
184 | 	if err != nil {
185 | 		log.Errorln("Unable to find the Primary MDM node")
186 | 		return "", err
187 | 	}
188 | 
189 | 	log.Debugln("Determined Gateway:", pri.IPAddress)
190 | 	return pri.IPAddress, nil
191 | }
192 | 


--------------------------------------------------------------------------------
/scaleio-executor/executor/common/iscaleionode.go:
--------------------------------------------------------------------------------
 1 | package common
 2 | 
 3 | import "github.com/codedellemc/scaleio-framework/scaleio-scheduler/types"
 4 | 
 5 | //IScaleioNode is the interface for implementing a ScaleIO node
 6 | type IScaleioNode interface {
 7 | 	GetSelfNode() *types.ScaleIONode
 8 | 	UpdateScaleIOState() *types.ScaleIOFramework
 9 | 	UpdateNodeState(nodeState int) error
10 | 	UpdateDevices() error
11 | 	UpdatePingNode() error
12 | 
13 | 	RunStateUnknown()
14 | 	RunStateCleanPrereqsReboot()
15 | 	RunStatePrerequisitesInstalled()
16 | 	RunStateBasePackagedInstalled()
17 | 	RunStateInitializeCluster()
18 | 	RunStateAddResourcesToScaleIO()
19 | 	RunStateInstallRexRay()
20 | 	RunStateCleanInstallReboot()
21 | 	RunStateSystemReboot()
22 | 	RunStateFinishInstall()
23 | 	RunStateUpgradeCluster()
24 | 	RunStateFatalInstall()
25 | }
26 | 


--------------------------------------------------------------------------------
/scaleio-executor/executor/common/waitstates.go:
--------------------------------------------------------------------------------
  1 | package common
  2 | 
  3 | import (
  4 | 	"time"
  5 | 
  6 | 	log "github.com/Sirupsen/logrus"
  7 | 	"github.com/codedellemc/scaleio-framework/scaleio-scheduler/types"
  8 | )
  9 | 
 10 | const (
 11 | 	//DelayBetweenCommandsInSeconds just like it says
 12 | 	DelayBetweenCommandsInSeconds = 5
 13 | 
 14 | 	//DelayIfInstalledInSeconds just like it says
 15 | 	DelayIfInstalledInSeconds = 5
 16 | 
 17 | 	//DelayOnVolumeCreateInSeconds just like it says
 18 | 	DelayOnVolumeCreateInSeconds = 20
 19 | 
 20 | 	//DelayForRebootInSeconds the amount of time to wait for the reboot
 21 | 	DelayForRebootInSeconds = 5
 22 | 
 23 | 	//WaitForRebootInSeconds the amount of time to wait for the reboot
 24 | 	WaitForRebootInSeconds = 120
 25 | 
 26 | 	//OfflineTimeForMdmNodesInSeconds is the max time an MDM node can be offline
 27 | 	OfflineTimeForMdmNodesInSeconds = 180
 28 | 
 29 | 	//PollStatusInSeconds the amount of time to wait before updating state
 30 | 	PollStatusInSeconds = 5
 31 | 
 32 | 	//PollAfterFatalInSeconds the amount of time to wait before checking
 33 | 	PollAfterFatalInSeconds = 3600
 34 | 
 35 | 	//PollForChangesInSeconds cluster working. check for changes.
 36 | 	PollForChangesInSeconds = 30
 37 | )
 38 | 
 39 | //RetrieveState is a call back to retrieve an update of the state
 40 | type RetrieveState func() (*types.ScaleIOFramework, error)
 41 | 
 42 | func waitForRunState(state *types.ScaleIOFramework, runState int, allNodes bool) bool {
 43 | 	for _, node := range state.ScaleIO.Nodes {
 44 | 		switch node.Persona {
 45 | 		case types.PersonaMdmPrimary:
 46 | 			if node.State < runState {
 47 | 				return false
 48 | 			}
 49 | 		case types.PersonaMdmSecondary:
 50 | 			if node.State < runState {
 51 | 				return false
 52 | 			}
 53 | 		case types.PersonaTb:
 54 | 			if node.State < runState {
 55 | 				return false
 56 | 			}
 57 | 		case types.PersonaNode:
 58 | 			if allNodes && node.State < runState {
 59 | 				return false
 60 | 			}
 61 | 		}
 62 | 	}
 63 | 
 64 | 	return true
 65 | }
 66 | 
 67 | //WaitForStableState waits until a state can successfully be retrieved
 68 | func WaitForStableState(getstate RetrieveState) *types.ScaleIOFramework {
 69 | 	var err error
 70 | 	var state *types.ScaleIOFramework
 71 | 	for {
 72 | 		state, err = getstate()
 73 | 		if err == nil {
 74 | 			log.Debugln("waitForState BREAK")
 75 | 			break
 76 | 		}
 77 | 		log.Debugln("Waiting for", PollStatusInSeconds, "seconds")
 78 | 		time.Sleep(time.Duration(PollStatusInSeconds) * time.Second)
 79 | 	}
 80 | 	return state
 81 | }
 82 | 
 83 | func waitForState(sio IScaleioNode, nodeState int, allNodes bool) *types.ScaleIOFramework {
 84 | 	var state *types.ScaleIOFramework
 85 | 	for {
 86 | 		state = sio.UpdateScaleIOState()
 87 | 		if waitForRunState(state, nodeState, allNodes) {
 88 | 			log.Debugln("Achieve state", nodeState, "among nodes")
 89 | 			break
 90 | 		}
 91 | 		log.Debugln("Waiting for", PollStatusInSeconds, "seconds")
 92 | 		time.Sleep(time.Duration(PollStatusInSeconds) * time.Second)
 93 | 	}
 94 | 	return state
 95 | }
 96 | 
 97 | //WaitForPrereqsFinish waits until all prereqs have been installed
 98 | func WaitForPrereqsFinish(sio IScaleioNode) {
 99 | 	waitForState(sio, types.StatePrerequisitesInstalled, false)
100 | }
101 | 
102 | //WaitForCleanPrereqsReboot waits until all systems are ready to reboot
103 | //after prereq install
104 | func WaitForCleanPrereqsReboot(sio IScaleioNode) {
105 | 	waitForState(sio, types.StateCleanPrereqsReboot, true)
106 | }
107 | 
108 | //WaitForBaseFinish waits until base ScaleIO components have been installed
109 | func WaitForBaseFinish(sio IScaleioNode) {
110 | 	waitForState(sio, types.StateBasePackagedInstalled, false)
111 | }
112 | 
113 | //WaitForClusterInstallFinish waits for the cluster to be created
114 | func WaitForClusterInstallFinish(sio IScaleioNode) {
115 | 	waitForState(sio, types.StateInitializeCluster, false)
116 | }
117 | 
118 | //WaitForClusterInitializeFinish wait until the cluster has been initialized
119 | func WaitForClusterInitializeFinish(sio IScaleioNode) {
120 | 	waitForState(sio, types.StateInstallRexRay, false)
121 | }
122 | 
123 | //WaitForCleanInstallReboot waits for reboot of nodes after install
124 | func WaitForCleanInstallReboot(sio IScaleioNode) {
125 | 	waitForState(sio, types.StateCleanInstallReboot, true)
126 | }
127 | 


--------------------------------------------------------------------------------
/scaleio-executor/executor/executor.go:
--------------------------------------------------------------------------------
  1 | package executor
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	"errors"
  6 | 	"fmt"
  7 | 	"io"
  8 | 	"io/ioutil"
  9 | 	"net/http"
 10 | 
 11 | 	log "github.com/Sirupsen/logrus"
 12 | 	xplatform "github.com/dvonthenen/goxplatform"
 13 | 	jsonpb "github.com/gogo/protobuf/jsonpb"
 14 | 	"github.com/gogo/protobuf/proto"
 15 | 
 16 | 	"github.com/codedellemc/scaleio-framework/scaleio-executor/client"
 17 | 	"github.com/codedellemc/scaleio-framework/scaleio-executor/config"
 18 | 	exec "github.com/codedellemc/scaleio-framework/scaleio-executor/mesos/exec"
 19 | 	mesos "github.com/codedellemc/scaleio-framework/scaleio-executor/mesos/v1"
 20 | 	types "github.com/codedellemc/scaleio-framework/scaleio-scheduler/types"
 21 | )
 22 | 
 23 | const (
 24 | 	numberOfEventFailuresBeforeExiting = 10
 25 | )
 26 | 
 27 | //ScaleIOExecutor is the representation for an ScaleIO Executor process
 28 | type ScaleIOExecutor struct {
 29 | 	Config *config.Config
 30 | 
 31 | 	ExecutorID  *mesos.ExecutorID
 32 | 	FrameworkID *mesos.FrameworkID
 33 | 
 34 | 	Client *client.Client
 35 | 
 36 | 	Events   chan *exec.Event
 37 | 	DoneChan chan struct{}
 38 | 
 39 | 	ObservedFailures int
 40 | }
 41 | 
 42 | //NewScaleIOExecutor creates a ScaleIO executor object
 43 | func NewScaleIOExecutor(cfg *config.Config) *ScaleIOExecutor {
 44 | 	return &ScaleIOExecutor{
 45 | 		Config:           cfg,
 46 | 		ExecutorID:       &mesos.ExecutorID{Value: proto.String(cfg.ExecutorID)},
 47 | 		FrameworkID:      &mesos.FrameworkID{Value: proto.String(cfg.FrameworkID)},
 48 | 		Client:           client.New(cfg.MesosAgent, "/api/v1/executor"),
 49 | 		Events:           make(chan *exec.Event),
 50 | 		DoneChan:         make(chan struct{}),
 51 | 		ObservedFailures: 0,
 52 | 	}
 53 | }
 54 | 
 55 | //Start kicks off the executor workflow
 56 | func (e *ScaleIOExecutor) Start() <-chan struct{} {
 57 | 	if err := e.subscribe(); err != nil {
 58 | 		log.Errorln(err)
 59 | 	}
 60 | 	go e.handleEvents()
 61 | 	return e.DoneChan
 62 | }
 63 | 
 64 | func (e *ScaleIOExecutor) stop() {
 65 | 	close(e.Events)
 66 | }
 67 | 
 68 | func (e *ScaleIOExecutor) retrieveState() (*types.ScaleIOFramework, error) {
 69 | 	log.Debugln("RetrieveState ENTER")
 70 | 	url := e.Config.SchedulerURI + "/api/state"
 71 | 
 72 | 	req, err := http.NewRequest("GET", url, nil)
 73 | 	if err != nil {
 74 | 		log.Errorln("Error is HTTP NewRequest:", err)
 75 | 		log.Debugln("RetrieveState LEAVE")
 76 | 		return nil, err
 77 | 	}
 78 | 
 79 | 	req.Header.Set("Content-Type", "application/json")
 80 | 
 81 | 	client := &http.Client{}
 82 | 	resp, err := client.Do(req)
 83 | 	if err != nil {
 84 | 		log.Errorln("Error is HTTP Do:", err)
 85 | 		log.Debugln("RetrieveState LEAVE")
 86 | 		return nil, err
 87 | 	}
 88 | 	defer resp.Body.Close()
 89 | 
 90 | 	body, err := ioutil.ReadAll(io.LimitReader(resp.Body, 1048576))
 91 | 	if err != nil {
 92 | 		log.Errorln("Error is IO ReadAll:", err)
 93 | 		log.Debugln("RetrieveState LEAVE")
 94 | 		return nil, err
 95 | 	}
 96 | 
 97 | 	log.Debugln("Body: ", string(body))
 98 | 
 99 | 	var state types.ScaleIOFramework
100 | 	err = json.Unmarshal(body, &state)
101 | 	if err != nil {
102 | 		log.Errorln("Error is IO ReadAll:", err)
103 | 		log.Debugln("RetrieveState LEAVE")
104 | 		return nil, err
105 | 	}
106 | 
107 | 	log.Debugln("RetrieveState Succeeded")
108 | 	log.Debugln("RetrieveState LEAVE")
109 | 
110 | 	return &state, nil
111 | }
112 | 
113 | func (e *ScaleIOExecutor) send(call *exec.Call) (*http.Response, error) {
114 | 	marshaler := jsonpb.Marshaler{
115 | 		EnumsAsInts:  true,
116 | 		EmitDefaults: false,
117 | 		Indent:       "  ",
118 | 		OrigName:     false,
119 | 	}
120 | 	strJSON, errJSON := marshaler.MarshalToString(call)
121 | 	if errJSON == nil {
122 | 		log.Debugln("JSON:\n", strJSON)
123 | 	} else {
124 | 		log.Debugln("Unable to marshal to JSON:", errJSON)
125 | 	}
126 | 
127 | 	payload, err := proto.Marshal(call)
128 | 	if err != nil {
129 | 		log.Errorln("Failed to Marshal Protobuf:", err)
130 | 		return nil, err
131 | 	}
132 | 
133 | 	resp, err := e.Client.Send(payload)
134 | 	if err != nil {
135 | 		return nil, err
136 | 	}
137 | 	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusAccepted {
138 | 		msg := fmt.Sprint("StatusCode is not equal to StatusOK:", resp.StatusCode)
139 | 		log.Errorln(msg)
140 | 		return nil, errors.New(msg)
141 | 	}
142 | 
143 | 	log.Infoln("StatusCode: StatusOK")
144 | 	return resp, nil
145 | }
146 | 
147 | func (e *ScaleIOExecutor) subscribe() error {
148 | 	call := &exec.Call{
149 | 		FrameworkId: e.FrameworkID,
150 | 		ExecutorId:  e.ExecutorID,
151 | 		Type:        exec.Call_SUBSCRIBE.Enum(),
152 | 		Subscribe: &exec.Call_Subscribe{
153 | 			UnacknowledgedTasks:   []*mesos.TaskInfo{},
154 | 			UnacknowledgedUpdates: []*exec.Call_Update{},
155 | 		},
156 | 	}
157 | 
158 | 	resp, err := e.send(call)
159 | 	if resp != nil {
160 | 		go e.qEvents(resp)
161 | 	}
162 | 	return err
163 | }
164 | 
165 | func (e *ScaleIOExecutor) qEvents(resp *http.Response) {
166 | 	log.Debugln("qEvents ENTER")
167 | 	defer func() {
168 | 		resp.Body.Close()
169 | 		close(e.Events)
170 | 	}()
171 | 
172 | 	dec := json.NewDecoder(resp.Body)
173 | 	for {
174 | 		event := new(exec.Event)
175 | 		if event == nil {
176 | 			log.Errorln("Event is nil")
177 | 		}
178 | 		log.Debugln("Waiting for Event")
179 | 		err := dec.Decode(event)
180 | 		log.Debugln("Received for Event")
181 | 		if err != nil {
182 | 			e.ObservedFailures = e.ObservedFailures + 1
183 | 			if e.ObservedFailures > numberOfEventFailuresBeforeExiting {
184 | 				log.Fatalln("Received too many invalid events. Lost communication to agent.")
185 | 				return
186 | 			}
187 | 			if err == io.EOF {
188 | 				log.Debugln("err == io.EOF")
189 | 				log.Debugln("qEvents LEAVE")
190 | 				return
191 | 			}
192 | 			log.Warnln("Error decoding event. Skip event. Err:", err)
193 | 			continue
194 | 		}
195 | 
196 | 		//TODO fix this at some point. This is due to the RecordIO Format
197 | 		// RecordIO = <Message LENGTH>\n<Message of Size=LENGTH>
198 | 		log.Debugln("Adding Event:", event.String())
199 | 		e.ObservedFailures = 0
200 | 		e.Events <- event
201 | 	}
202 | }
203 | 
204 | func (e *ScaleIOExecutor) handleEvents() {
205 | 	defer close(e.DoneChan)
206 | 	for ev := range e.Events {
207 | 		switch ev.GetType() {
208 | 
209 | 		case exec.Event_SUBSCRIBED:
210 | 			sub := ev.GetSubscribed()
211 | 			log.Infoln("[EVENT] Executor SUBSCRIBED with id:", sub.GetExecutorInfo().GetExecutorId())
212 | 			log.Debugln("AgentInfo:", sub.GetAgentInfo().String())
213 | 
214 | 		case exec.Event_LAUNCH:
215 | 			task := ev.GetLaunch().GetTask()
216 | 			log.Infoln("[EVENT] LAUNCH:", task.GetTaskId().GetValue())
217 | 			log.Debugln("Task:", task.String())
218 | 
219 | 			err := e.sendUpdate(task, mesos.TaskState_TASK_RUNNING.Enum())
220 | 			if err != nil {
221 | 				log.Errorln("Failed while sending update:", err)
222 | 			}
223 | 
224 | 			go func() {
225 | 				//TODO reminder not to rely on node.LastContact value until we add in pings
226 | 				errNode := RunExecutor(e.Config, e.retrieveState)
227 | 				if errNode != nil {
228 | 					myErr := e.sendUpdate(task, mesos.TaskState_TASK_ERROR.Enum())
229 | 					if myErr != nil {
230 | 						log.Errorln("Failed while sending update:", myErr)
231 | 					}
232 | 				}
233 | 			}()
234 | 
235 | 		case exec.Event_ACKNOWLEDGED:
236 | 			log.Infoln("[EVENT] Received ACKNOWLEDGED:", ev.GetAcknowledged().String())
237 | 
238 | 		case exec.Event_MESSAGE:
239 | 			log.Infoln("[EVENT] Received MESSAGE:", ev.GetMessage().String())
240 | 
241 | 		case exec.Event_KILL:
242 | 			log.Infoln("[EVENT] Received KILL")
243 | 
244 | 		case exec.Event_SHUTDOWN:
245 | 			log.Infoln("[EVENT] Received SHUTDOWN")
246 | 			e.stop()
247 | 
248 | 		case exec.Event_ERROR:
249 | 			log.Infoln("[EVENT] Received ERROR")
250 | 			err := ev.GetError().GetMessage()
251 | 			log.Infoln(err)
252 | 		}
253 | 	}
254 | }
255 | 
256 | func (e *ScaleIOExecutor) sendUpdate(task *mesos.TaskInfo, state *mesos.TaskState) error {
257 | 	log.Debugln("sendUpdate ENTER")
258 | 	log.Debugln("FrameworkID:", e.FrameworkID.String())
259 | 	log.Debugln("ExecutorID:", e.ExecutorID.String())
260 | 	log.Debugln("TaskId:", task.GetTaskId().String())
261 | 	log.Debugln("State:", state.String())
262 | 
263 | 	call := &exec.Call{
264 | 		Type:        exec.Call_UPDATE.Enum(),
265 | 		FrameworkId: e.FrameworkID,
266 | 		ExecutorId:  e.ExecutorID,
267 | 		Update: &exec.Call_Update{
268 | 			Status: &mesos.TaskStatus{
269 | 				TaskId:     task.TaskId,
270 | 				ExecutorId: e.ExecutorID,
271 | 				State:      state,
272 | 				Source:     mesos.TaskStatus_SOURCE_EXECUTOR.Enum(),
273 | 				Uuid:       []byte(xplatform.GetInstance().Sys.GetUUID()),
274 | 			},
275 | 		},
276 | 	}
277 | 
278 | 	log.Debugln("Call:", call.String())
279 | 
280 | 	_, err := e.send(call)
281 | 	return err
282 | }
283 | 


--------------------------------------------------------------------------------
/scaleio-executor/executor/pkgmgr/deb/ubuntu14/common.go:
--------------------------------------------------------------------------------
 1 | package ubuntu14
 2 | 
 3 | const (
 4 | 	//Environment
 5 | 	aiozipCheck                = "[0-9]+ upgraded|[0-9]+ newly"
 6 | 	genericInstallCheck        = "1 upgraded|1 newly"
 7 | 	requiredKernelVersionCheck = "4.4.0-38-generic"
 8 | 
 9 | 	//ScaleIO node
10 | 	mdmInstallCheck     = "mdm start/running"
11 | 	sdsInstallCheck     = "sds start/running"
12 | 	sdcInstallCheck     = "Success configuring module"
13 | 	liaInstallCheck     = "lia start/running"
14 | 	gatewayInstallCheck = "The EMC ScaleIO Gateway is running"
15 | 
16 | 	//REX-Ray
17 | 	rexrayInstallCheck = "rexray has been installed to"
18 | 
19 | 	//Isolator
20 | 	dvdcliInstallCheck = "dvdcli has been installed to"
21 | )
22 | 


--------------------------------------------------------------------------------
/scaleio-executor/executor/pkgmgr/deb/ubuntu14/mdmdebmgr.go:
--------------------------------------------------------------------------------
  1 | package ubuntu14
  2 | 
  3 | import (
  4 | 	log "github.com/Sirupsen/logrus"
  5 | 	xplatform "github.com/dvonthenen/goxplatform"
  6 | 
  7 | 	mgr "github.com/codedellemc/scaleio-framework/scaleio-executor/executor/pkgmgr/mgr"
  8 | 	types "github.com/codedellemc/scaleio-framework/scaleio-scheduler/types"
  9 | )
 10 | 
 11 | //MdmDebMgr implementation for MdmDebMgr
 12 | type MdmDebUbuntu14Mgr struct {
 13 | 	*mgr.MdmManager
 14 | }
 15 | 
 16 | //EnvironmentSetup for setting up the environment for ScaleIO
 17 | func (mdm *MdmDebUbuntu14Mgr) EnvironmentSetup(state *types.ScaleIOFramework) (bool, error) {
 18 | 	log.Infoln("EnvironmentSetup ENTER")
 19 | 
 20 | 	aioErr := xplatform.GetInstance().Inst.IsInstalled("libaio1")
 21 | 	zipErr := xplatform.GetInstance().Inst.IsInstalled("zip")
 22 | 	if aioErr != nil || zipErr != nil {
 23 | 		log.Infoln("Installing libaio1 and zip")
 24 | 
 25 | 		miscCmdline := "apt-get -y install libaio1 zip"
 26 | 		err := xplatform.GetInstance().Run.Command(miscCmdline, aiozipCheck, "")
 27 | 		if err != nil {
 28 | 			log.Errorln("Install Prerequisites Failed:", err)
 29 | 			log.Infoln("EnvironmentSetup LEAVE")
 30 | 			return false, err
 31 | 		}
 32 | 	} else {
 33 | 		log.Infoln("libaio1 and zip are already installed")
 34 | 	}
 35 | 
 36 | 	kernelErr := xplatform.GetInstance().Inst.IsInstalled("linux-image-4.4.0-38-generic")
 37 | 	if kernelErr != nil {
 38 | 		log.Infoln("Installing linux-image-4.4.0-38-generic")
 39 | 
 40 | 		kernelCmdline := "apt-get -y install linux-image-4.4.0-38-generic"
 41 | 		err := xplatform.GetInstance().Run.Command(kernelCmdline, genericInstallCheck, "")
 42 | 		if err != nil {
 43 | 			log.Errorln("Install Kernel Failed:", err)
 44 | 			log.Infoln("EnvironmentSetup LEAVE")
 45 | 			return false, err
 46 | 		}
 47 | 	} else {
 48 | 		log.Infoln("linux-image-4.4.0-38-generic is already installed")
 49 | 	}
 50 | 
 51 | 	//get running kernel version
 52 | 	kernelVer, kernelVerErr := xplatform.GetInstance().Sys.GetRunningKernelVersion()
 53 | 	if kernelVerErr != nil {
 54 | 		log.Errorln("Kernel Version Check Failed:", kernelVerErr)
 55 | 		log.Infoln("EnvironmentSetup LEAVE")
 56 | 		return false, kernelVerErr
 57 | 	}
 58 | 
 59 | 	if kernelVer != requiredKernelVersionCheck {
 60 | 		log.Errorln("Kernel is installed but not running. Reboot Required!")
 61 | 		log.Infoln("EnvironmentSetup LEAVE")
 62 | 		return true, nil
 63 | 	}
 64 | 	log.Infoln("Already running kernel version", requiredKernelVersionCheck)
 65 | 	//get running kernel version
 66 | 
 67 | 	log.Infoln("EnvironmentSetup Succeeded")
 68 | 	log.Infoln("EnvironmentSetup LEAVE")
 69 | 	return false, nil
 70 | }
 71 | 
 72 | //NewMdmDebUbuntu14Mgr generates a MdmDebMgr object
 73 | func NewMdmDebUbuntu14Mgr(state *types.ScaleIOFramework) *MdmDebUbuntu14Mgr {
 74 | 	myMdmMgr := &mgr.MdmManager{}
 75 | 	myMdmDebUbuntu14Mgr := &MdmDebUbuntu14Mgr{myMdmMgr}
 76 | 
 77 | 	//ScaleIO node
 78 | 	myMdmDebUbuntu14Mgr.MdmManager.SdsPackageName = types.Ubuntu14SdsPackageName
 79 | 	myMdmDebUbuntu14Mgr.MdmManager.SdsPackageDownload = state.ScaleIO.Ubuntu14.Sds
 80 | 	myMdmDebUbuntu14Mgr.MdmManager.SdsInstallCmd = "dpkg -i {LocalSds}"
 81 | 	myMdmDebUbuntu14Mgr.MdmManager.SdsInstallCheck = sdsInstallCheck
 82 | 	myMdmDebUbuntu14Mgr.MdmManager.SdcPackageName = types.Ubuntu14SdcPackageName
 83 | 	myMdmDebUbuntu14Mgr.MdmManager.SdcPackageDownload = state.ScaleIO.Ubuntu14.Sdc
 84 | 	myMdmDebUbuntu14Mgr.MdmManager.SdcInstallCmd = "MDM_IP={MdmPair} dpkg -i {LocalSdc}"
 85 | 	myMdmDebUbuntu14Mgr.MdmManager.SdcInstallCheck = sdcInstallCheck
 86 | 	myMdmDebUbuntu14Mgr.MdmManager.MdmPackageName = types.Ubuntu14MdmPackageName
 87 | 	myMdmDebUbuntu14Mgr.MdmManager.MdmPackageDownload = state.ScaleIO.Ubuntu14.Mdm
 88 | 	myMdmDebUbuntu14Mgr.MdmManager.MdmInstallCmd = "MDM_ROLE_IS_MANAGER={PriOrSec} dpkg -i {LocalMdm}"
 89 | 	myMdmDebUbuntu14Mgr.MdmManager.MdmInstallCheck = mdmInstallCheck
 90 | 	myMdmDebUbuntu14Mgr.MdmManager.LiaPackageName = types.Ubuntu14LiaPackageName
 91 | 	myMdmDebUbuntu14Mgr.MdmManager.LiaPackageDownload = state.ScaleIO.Ubuntu14.Lia
 92 | 	myMdmDebUbuntu14Mgr.MdmManager.LiaInstallCmd = "TOKEN=" + state.ScaleIO.AdminPassword + " dpkg -i {LocalLia}"
 93 | 	myMdmDebUbuntu14Mgr.MdmManager.LiaInstallCheck = liaInstallCheck
 94 | 	myMdmDebUbuntu14Mgr.MdmManager.GatewayPackageName = types.Ubuntu14GwPackageName
 95 | 	myMdmDebUbuntu14Mgr.MdmManager.GatewayPackageDownload = state.ScaleIO.Ubuntu14.Gw
 96 | 	myMdmDebUbuntu14Mgr.MdmManager.GatewayInstallCmd = "GATEWAY_ADMIN_PASSWORD=" + state.ScaleIO.AdminPassword + " dpkg -i {LocalGw}"
 97 | 	myMdmDebUbuntu14Mgr.MdmManager.GatewayInstallCheck = gatewayInstallCheck
 98 | 
 99 | 	//REX-Ray
100 | 	myMdmDebUbuntu14Mgr.MdmManager.RexrayInstallCheck = rexrayInstallCheck
101 | 
102 | 	//Isolator
103 | 	myMdmDebUbuntu14Mgr.MdmManager.DvdcliInstallCheck = dvdcliInstallCheck
104 | 
105 | 	return myMdmDebUbuntu14Mgr
106 | }
107 | 


--------------------------------------------------------------------------------
/scaleio-executor/executor/pkgmgr/deb/ubuntu14/nodedebmgr.go:
--------------------------------------------------------------------------------
 1 | package ubuntu14
 2 | 
 3 | import (
 4 | 	log "github.com/Sirupsen/logrus"
 5 | 	xplatform "github.com/dvonthenen/goxplatform"
 6 | 
 7 | 	mgr "github.com/codedellemc/scaleio-framework/scaleio-executor/executor/pkgmgr/mgr"
 8 | 	types "github.com/codedellemc/scaleio-framework/scaleio-scheduler/types"
 9 | )
10 | 
11 | //NodeDebUbuntu14Mgr implementation for NodeDebUbuntu14Mgr
12 | type NodeDebUbuntu14Mgr struct {
13 | 	*mgr.NodeManager
14 | }
15 | 
16 | //EnvironmentSetup for setting up the environment for ScaleIO
17 | func (dpm *NodeDebUbuntu14Mgr) EnvironmentSetup(state *types.ScaleIOFramework) (bool, error) {
18 | 	log.Infoln("EnvironmentSetup ENTER")
19 | 
20 | 	aioErr := xplatform.GetInstance().Inst.IsInstalled("libaio1")
21 | 	zipErr := xplatform.GetInstance().Inst.IsInstalled("zip")
22 | 	if aioErr != nil || zipErr != nil {
23 | 		log.Infoln("Installing libaio1 and zip")
24 | 
25 | 		miscCmdline := "apt-get -y install libaio1 zip"
26 | 		err := xplatform.GetInstance().Run.Command(miscCmdline, aiozipCheck, "")
27 | 		if err != nil {
28 | 			log.Errorln("Install Prerequisites Failed:", err)
29 | 			log.Infoln("EnvironmentSetup LEAVE")
30 | 			return false, err
31 | 		}
32 | 	} else {
33 | 		log.Infoln("libaio1 and zip are already installed")
34 | 	}
35 | 
36 | 	kernelErr := xplatform.GetInstance().Inst.IsInstalled("linux-image-4.4.0-38-generic")
37 | 	if kernelErr != nil {
38 | 		log.Infoln("Installing linux-image-4.4.0-38-generic")
39 | 
40 | 		kernelCmdline := "apt-get -y install linux-image-4.4.0-38-generic"
41 | 		err := xplatform.GetInstance().Run.Command(kernelCmdline, genericInstallCheck, "")
42 | 		if err != nil {
43 | 			log.Errorln("Install Kernel Failed:", err)
44 | 			log.Infoln("EnvironmentSetup LEAVE")
45 | 			return false, err
46 | 		}
47 | 	} else {
48 | 		log.Infoln("linux-image-4.4.0-38-generic is already installed")
49 | 	}
50 | 
51 | 	//get running kernel version
52 | 	kernelVer, kernelVerErr := xplatform.GetInstance().Sys.GetRunningKernelVersion()
53 | 	if kernelVerErr != nil {
54 | 		log.Errorln("Kernel Version Check Failed:", kernelVerErr)
55 | 		log.Infoln("EnvironmentSetup LEAVE")
56 | 		return false, kernelVerErr
57 | 	}
58 | 
59 | 	if kernelVer != requiredKernelVersionCheck {
60 | 		log.Errorln("Kernel is installed but not running. Reboot Required!")
61 | 		log.Infoln("EnvironmentSetup LEAVE")
62 | 		return true, nil
63 | 	}
64 | 	log.Infoln("Already running kernel version", requiredKernelVersionCheck)
65 | 	//get running kernel version
66 | 
67 | 	log.Infoln("EnvironmentSetup Succeeded")
68 | 	log.Infoln("EnvironmentSetup LEAVE")
69 | 	return false, nil
70 | }
71 | 
72 | //NewNodeDebUbuntu14Mgr generates a NodeDebMgr object
73 | func NewNodeDebUbuntu14Mgr(state *types.ScaleIOFramework) *NodeDebUbuntu14Mgr {
74 | 	myNodeMgr := &mgr.NodeManager{}
75 | 	myNodeDebUbuntu14Mgr := &NodeDebUbuntu14Mgr{myNodeMgr}
76 | 
77 | 	//ScaleIO node
78 | 	myNodeDebUbuntu14Mgr.NodeManager.SdsPackageName = types.Ubuntu14SdsPackageName
79 | 	myNodeDebUbuntu14Mgr.NodeManager.SdsPackageDownload = state.ScaleIO.Ubuntu14.Sds
80 | 	myNodeDebUbuntu14Mgr.NodeManager.SdsInstallCmd = "dpkg -i {LocalSds}"
81 | 	myNodeDebUbuntu14Mgr.NodeManager.SdsInstallCheck = sdsInstallCheck
82 | 	myNodeDebUbuntu14Mgr.NodeManager.SdcPackageName = types.Ubuntu14SdcPackageName
83 | 	myNodeDebUbuntu14Mgr.NodeManager.SdcPackageDownload = state.ScaleIO.Ubuntu14.Sdc
84 | 	myNodeDebUbuntu14Mgr.NodeManager.SdcInstallCmd = "MDM_IP={MdmPair} dpkg -i {LocalSdc}"
85 | 	myNodeDebUbuntu14Mgr.NodeManager.SdcInstallCheck = sdcInstallCheck
86 | 
87 | 	//REX-Ray
88 | 	myNodeDebUbuntu14Mgr.NodeManager.RexrayInstallCheck = rexrayInstallCheck
89 | 
90 | 	//Isolator
91 | 	myNodeDebUbuntu14Mgr.NodeManager.DvdcliInstallCheck = dvdcliInstallCheck
92 | 
93 | 	return myNodeDebUbuntu14Mgr
94 | }
95 | 


--------------------------------------------------------------------------------
/scaleio-executor/executor/pkgmgr/mgr/imdmmgr.go:
--------------------------------------------------------------------------------
 1 | package mgr
 2 | 
 3 | import (
 4 | 	types "github.com/codedellemc/scaleio-framework/scaleio-scheduler/types"
 5 | )
 6 | 
 7 | //IMdmMgr abstracts the Package Manager for MDM nodes on the platform
 8 | type IMdmMgr interface {
 9 | 	INodeMgr
10 | 
11 | 	ManagementSetup(state *types.ScaleIOFramework, isPriOrSec bool) error
12 | 	CreateCluster(state *types.ScaleIOFramework) error
13 | 	GatewaySetup(state *types.ScaleIOFramework) (bool, error)
14 | }
15 | 


--------------------------------------------------------------------------------
/scaleio-executor/executor/pkgmgr/mgr/inodemgr.go:
--------------------------------------------------------------------------------
 1 | package mgr
 2 | 
 3 | import (
 4 | 	types "github.com/codedellemc/scaleio-framework/scaleio-scheduler/types"
 5 | )
 6 | 
 7 | //INodeMgr abstracts the Package Manager for ScaleIO node on the platform
 8 | type INodeMgr interface {
 9 | 	EnvironmentSetup(state *types.ScaleIOFramework) (bool, error)
10 | 	NodeSetup(state *types.ScaleIOFramework) error
11 | 
12 | 	RexraySetup(state *types.ScaleIOFramework, executorID string) (bool, error)
13 | 	SetupIsolator(state *types.ScaleIOFramework) error
14 | }
15 | 


--------------------------------------------------------------------------------
/scaleio-executor/executor/pkgmgr/mgr/mdmmgr.go:
--------------------------------------------------------------------------------
 1 | package mgr
 2 | 
 3 | //MdmManager implementation for MDM Package Manager
 4 | type MdmManager struct {
 5 | 	NodeManager
 6 | 
 7 | 	//ScaleIO node
 8 | 	MdmPackageName         string
 9 | 	MdmPackageDownload     string
10 | 	MdmInstallCmd          string
11 | 	MdmInstallCheck        string
12 | 	LiaPackageName         string
13 | 	LiaPackageDownload     string
14 | 	LiaInstallCmd          string
15 | 	LiaInstallCheck        string
16 | 	GatewayPackageName     string
17 | 	GatewayPackageDownload string
18 | 	GatewayInstallCmd      string
19 | 	GatewayInstallCheck    string
20 | }
21 | 


--------------------------------------------------------------------------------
/scaleio-executor/executor/pkgmgr/mgr/nodemgr.go:
--------------------------------------------------------------------------------
 1 | package mgr
 2 | 
 3 | import "errors"
 4 | 
 5 | var (
 6 | 	//ErrBaseUnimplemented failed because function is unimplemented in the base class
 7 | 	ErrBaseUnimplemented = errors.New("Function is unimplemented in the base class")
 8 | )
 9 | 
10 | //NodeManager implementation for Package Manager for ScaleIO Nodes
11 | type NodeManager struct {
12 | 	//ScaleIO node
13 | 	SdsPackageName     string
14 | 	SdsPackageDownload string
15 | 	SdsInstallCmd      string
16 | 	SdsInstallCheck    string
17 | 	SdcPackageName     string
18 | 	SdcPackageDownload string
19 | 	SdcInstallCmd      string
20 | 	SdcInstallCheck    string
21 | 
22 | 	//REX-Ray
23 | 	RexrayInstallCheck string
24 | 
25 | 	//Isolator
26 | 	DvdcliInstallCheck string
27 | }
28 | 


--------------------------------------------------------------------------------
/scaleio-executor/executor/pkgmgr/rpm/rhel7/common.go:
--------------------------------------------------------------------------------
 1 | package rhel7
 2 | 
 3 | const (
 4 | 	//Environment
 5 | 	aiozipCheck = "Nothing to do|Installed:|Complete!"
 6 | 
 7 | 	//ScaleIO node
 8 | 	mdmInstallCheck     = "Created symlink from"
 9 | 	sdsInstallCheck     = "Created symlink from"
10 | 	sdcInstallCheck     = "Starting scini"
11 | 	liaInstallCheck     = "Created symlink from"
12 | 	gatewayInstallCheck = "The EMC ScaleIO Gateway is running"
13 | 
14 | 	//REX-Ray
15 | 	rexrayInstallCheck = "rexray has been installed to"
16 | 
17 | 	//Isolator
18 | 	dvdcliInstallCheck = "dvdcli has been installed to"
19 | )
20 | 


--------------------------------------------------------------------------------
/scaleio-executor/executor/pkgmgr/rpm/rhel7/mdmrpmmgr.go:
--------------------------------------------------------------------------------
 1 | package rhel7
 2 | 
 3 | import (
 4 | 	log "github.com/Sirupsen/logrus"
 5 | 	xplatform "github.com/dvonthenen/goxplatform"
 6 | 
 7 | 	mgr "github.com/codedellemc/scaleio-framework/scaleio-executor/executor/pkgmgr/mgr"
 8 | 	types "github.com/codedellemc/scaleio-framework/scaleio-scheduler/types"
 9 | )
10 | 
11 | //MdmRpmRhel7Mgr implementation for MdmRpmRhel7Mgr
12 | type MdmRpmRhel7Mgr struct {
13 | 	*mgr.MdmManager
14 | }
15 | 
16 | //EnvironmentSetup for setting up the environment for ScaleIO
17 | func (mdm *MdmRpmRhel7Mgr) EnvironmentSetup(state *types.ScaleIOFramework) (bool, error) {
18 | 	log.Infoln("EnvironmentSetup ENTER")
19 | 
20 | 	aioErr := xplatform.GetInstance().Inst.IsInstalled("libaio")
21 | 	zipErr := xplatform.GetInstance().Inst.IsInstalled("zip")
22 | 	unzipErr := xplatform.GetInstance().Inst.IsInstalled("unzip")
23 | 	javaErr := xplatform.GetInstance().Inst.IsInstalled("java-1.8.0-openjdk")
24 | 	if aioErr != nil || zipErr != nil || unzipErr != nil || javaErr != nil {
25 | 		log.Infoln("Installing libaio1, zip, and java-1.8.0-openjdk")
26 | 
27 | 		miscCmdline := "yum -y install zip unzip libaio java-1.8.0-openjdk"
28 | 		err := xplatform.GetInstance().Run.Command(miscCmdline, aiozipCheck, "")
29 | 		if err != nil {
30 | 			log.Errorln("Install Prerequisites Failed:", err)
31 | 			log.Infoln("EnvironmentSetup LEAVE")
32 | 			return false, err
33 | 		}
34 | 	} else {
35 | 		log.Infoln("libaio1, zip, and java-1.8.0-openjdk are already installed")
36 | 	}
37 | 
38 | 	log.Infoln("EnvironmentSetup LEAVE")
39 | 
40 | 	return false, nil
41 | }
42 | 
43 | //NewMdmRpmRhel7Mgr generates a MdmRpmRhel7Mgr object
44 | func NewMdmRpmRhel7Mgr(state *types.ScaleIOFramework) *MdmRpmRhel7Mgr {
45 | 	myMdmMgr := &mgr.MdmManager{}
46 | 	myMdmRpmRhel7Mgr := &MdmRpmRhel7Mgr{myMdmMgr}
47 | 
48 | 	//ScaleIO node
49 | 	myMdmRpmRhel7Mgr.MdmManager.SdsPackageName = types.Rhel7SdsPackageName
50 | 	myMdmRpmRhel7Mgr.MdmManager.SdsPackageDownload = state.ScaleIO.Rhel7.Sds
51 | 	myMdmRpmRhel7Mgr.MdmManager.SdsInstallCmd = "rpm -Uvh {LocalSds}"
52 | 	myMdmRpmRhel7Mgr.MdmManager.SdsInstallCheck = sdsInstallCheck
53 | 	myMdmRpmRhel7Mgr.MdmManager.SdcPackageName = types.Rhel7SdcPackageName
54 | 	myMdmRpmRhel7Mgr.MdmManager.SdcPackageDownload = state.ScaleIO.Rhel7.Sdc
55 | 	myMdmRpmRhel7Mgr.MdmManager.SdcInstallCmd = "MDM_IP={MdmPair} rpm -Uvh {LocalSdc}"
56 | 	myMdmRpmRhel7Mgr.MdmManager.SdcInstallCheck = sdcInstallCheck
57 | 	myMdmRpmRhel7Mgr.MdmManager.MdmPackageName = types.Rhel7MdmPackageName
58 | 	myMdmRpmRhel7Mgr.MdmManager.MdmPackageDownload = state.ScaleIO.Rhel7.Mdm
59 | 	myMdmRpmRhel7Mgr.MdmManager.MdmInstallCmd = "MDM_ROLE_IS_MANAGER={PriOrSec} rpm -Uvh {LocalMdm}"
60 | 	myMdmRpmRhel7Mgr.MdmManager.MdmInstallCheck = mdmInstallCheck
61 | 	myMdmRpmRhel7Mgr.MdmManager.LiaPackageName = types.Rhel7LiaPackageName
62 | 	myMdmRpmRhel7Mgr.MdmManager.LiaPackageDownload = state.ScaleIO.Rhel7.Lia
63 | 	myMdmRpmRhel7Mgr.MdmManager.LiaInstallCmd = "TOKEN=" + state.ScaleIO.AdminPassword + " rpm -Uvh {LocalLia}"
64 | 	myMdmRpmRhel7Mgr.MdmManager.LiaInstallCheck = liaInstallCheck
65 | 	myMdmRpmRhel7Mgr.MdmManager.GatewayPackageName = types.Rhel7GwPackageName
66 | 	myMdmRpmRhel7Mgr.MdmManager.GatewayPackageDownload = state.ScaleIO.Rhel7.Gw
67 | 	myMdmRpmRhel7Mgr.MdmManager.GatewayInstallCmd = "GATEWAY_ADMIN_PASSWORD=" + state.ScaleIO.AdminPassword + " rpm -Uvh {LocalGw}"
68 | 	myMdmRpmRhel7Mgr.MdmManager.GatewayInstallCheck = gatewayInstallCheck
69 | 
70 | 	//REX-Ray
71 | 	myMdmRpmRhel7Mgr.MdmManager.RexrayInstallCheck = rexrayInstallCheck
72 | 
73 | 	//Isolator
74 | 	myMdmRpmRhel7Mgr.MdmManager.DvdcliInstallCheck = dvdcliInstallCheck
75 | 
76 | 	return myMdmRpmRhel7Mgr
77 | }
78 | 


--------------------------------------------------------------------------------
/scaleio-executor/executor/pkgmgr/rpm/rhel7/noderpmmgr.go:
--------------------------------------------------------------------------------
 1 | package rhel7
 2 | 
 3 | import (
 4 | 	log "github.com/Sirupsen/logrus"
 5 | 	xplatform "github.com/dvonthenen/goxplatform"
 6 | 
 7 | 	mgr "github.com/codedellemc/scaleio-framework/scaleio-executor/executor/pkgmgr/mgr"
 8 | 	types "github.com/codedellemc/scaleio-framework/scaleio-scheduler/types"
 9 | )
10 | 
11 | //NodeRpmRhel7Mgr implementation for NodeRpmRhel7Mgr
12 | type NodeRpmRhel7Mgr struct {
13 | 	*mgr.NodeManager
14 | }
15 | 
16 | //EnvironmentSetup for setting up the environment for ScaleIO
17 | func (npm *NodeRpmRhel7Mgr) EnvironmentSetup(state *types.ScaleIOFramework) (bool, error) {
18 | 	log.Infoln("EnvironmentSetup ENTER")
19 | 
20 | 	aioErr := xplatform.GetInstance().Inst.IsInstalled("libaio")
21 | 	zipErr := xplatform.GetInstance().Inst.IsInstalled("zip")
22 | 	unzipErr := xplatform.GetInstance().Inst.IsInstalled("unzip")
23 | 	javaErr := xplatform.GetInstance().Inst.IsInstalled("java-1.8.0-openjdk")
24 | 	if aioErr != nil || zipErr != nil || unzipErr != nil || javaErr != nil {
25 | 		log.Infoln("Installing libaio1, zip, and java-1.8.0-openjdk")
26 | 
27 | 		miscCmdline := "yum -y install zip unzip libaio java-1.8.0-openjdk"
28 | 		err := xplatform.GetInstance().Run.Command(miscCmdline, aiozipCheck, "")
29 | 		if err != nil {
30 | 			log.Errorln("Install Prerequisites Failed:", err)
31 | 			log.Infoln("EnvironmentSetup LEAVE")
32 | 			return false, err
33 | 		}
34 | 	} else {
35 | 		log.Infoln("libaio1, zip, and java-1.8.0-openjdk are already installed")
36 | 	}
37 | 
38 | 	log.Infoln("EnvironmentSetup LEAVE")
39 | 
40 | 	return false, nil
41 | }
42 | 
43 | //NewNodeRpmRhel7Mgr generates a NodeRpmRhel7Mgr object
44 | func NewNodeRpmRhel7Mgr(state *types.ScaleIOFramework) *NodeRpmRhel7Mgr {
45 | 	myNodeMgr := &mgr.NodeManager{}
46 | 	myNodeRpmRhel7Mgr := &NodeRpmRhel7Mgr{myNodeMgr}
47 | 
48 | 	//ScaleIO node
49 | 	myNodeRpmRhel7Mgr.NodeManager.SdsPackageName = types.Rhel7SdsPackageName
50 | 	myNodeRpmRhel7Mgr.NodeManager.SdsPackageDownload = state.ScaleIO.Rhel7.Sds
51 | 	myNodeRpmRhel7Mgr.NodeManager.SdsInstallCmd = "rpm -Uvh {LocalSds}"
52 | 	myNodeRpmRhel7Mgr.NodeManager.SdsInstallCheck = sdsInstallCheck
53 | 	myNodeRpmRhel7Mgr.NodeManager.SdcPackageName = types.Rhel7SdcPackageName
54 | 	myNodeRpmRhel7Mgr.NodeManager.SdcPackageDownload = state.ScaleIO.Rhel7.Sdc
55 | 	myNodeRpmRhel7Mgr.NodeManager.SdcInstallCmd = "MDM_IP={MdmPair} rpm -Uvh {LocalSdc}"
56 | 	myNodeRpmRhel7Mgr.NodeManager.SdcInstallCheck = sdcInstallCheck
57 | 
58 | 	//REX-Ray
59 | 	myNodeRpmRhel7Mgr.NodeManager.RexrayInstallCheck = rexrayInstallCheck
60 | 
61 | 	//Isolator
62 | 	myNodeRpmRhel7Mgr.NodeManager.DvdcliInstallCheck = dvdcliInstallCheck
63 | 
64 | 	return myNodeRpmRhel7Mgr
65 | }
66 | 


--------------------------------------------------------------------------------
/scaleio-executor/executor/runnode.go:
--------------------------------------------------------------------------------
  1 | package executor
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 	"time"
  6 | 
  7 | 	log "github.com/Sirupsen/logrus"
  8 | 
  9 | 	config "github.com/codedellemc/scaleio-framework/scaleio-executor/config"
 10 | 	common "github.com/codedellemc/scaleio-framework/scaleio-executor/executor/common"
 11 | 	scaleionodes "github.com/codedellemc/scaleio-framework/scaleio-executor/executor/scaleionodes"
 12 | 	types "github.com/codedellemc/scaleio-framework/scaleio-scheduler/types"
 13 | )
 14 | 
 15 | var (
 16 | 	//ErrFoundSelfFailed found myself failed
 17 | 	ErrFoundSelfFailed = errors.New("Failed to locate self node")
 18 | )
 19 | 
 20 | func whichNode(cfg *config.Config, getstate common.RetrieveState) (common.IScaleioNode, error) {
 21 | 	log.Infoln("WhichNode ENTER")
 22 | 
 23 | 	log.Infoln("ScaleIO Executor Retrieve State from Scheduler")
 24 | 	state := common.WaitForStableState(getstate)
 25 | 
 26 | 	log.Infoln("Find Self Node")
 27 | 	node := common.GetSelfNode(state, cfg.ExecutorID)
 28 | 	if node == nil {
 29 | 		log.Infoln("GetSelfNode Failed")
 30 | 		log.Infoln("WhichNode LEAVE")
 31 | 		return nil, ErrFoundSelfFailed
 32 | 	}
 33 | 
 34 | 	var sionode common.IScaleioNode
 35 | 
 36 | 	switch node.Persona {
 37 | 	case types.PersonaMdmPrimary:
 38 | 		log.Infoln("Is Primary")
 39 | 		sionode = scaleionodes.NewPri(state, cfg, getstate)
 40 | 	case types.PersonaMdmSecondary:
 41 | 		log.Infoln("Is Secondary")
 42 | 		sionode = scaleionodes.NewSec(state, cfg, getstate)
 43 | 	case types.PersonaTb:
 44 | 		log.Infoln("Is TieBreaker")
 45 | 		sionode = scaleionodes.NewTb(state, cfg, getstate)
 46 | 	case types.PersonaNode:
 47 | 		log.Infoln("Is DataNode")
 48 | 		sionode = scaleionodes.NewData(state, cfg, getstate)
 49 | 	}
 50 | 
 51 | 	log.Infoln("WhichNode Succeeded")
 52 | 	log.Infoln("WhichNode LEAVE")
 53 | 	return sionode, nil
 54 | }
 55 | 
 56 | //RunExecutor starts the executor
 57 | func RunExecutor(cfg *config.Config, getstate common.RetrieveState) error {
 58 | 	log.Infoln("RunExecutor ENTER")
 59 | 	log.Infoln("executorID:", cfg.ExecutorID)
 60 | 
 61 | 	node, err := whichNode(cfg, getstate)
 62 | 	if err != nil {
 63 | 		log.Errorln("Unable to find Self in node list")
 64 | 		log.Infoln("RunExecutor LEAVE")
 65 | 		return ErrFoundSelfFailed
 66 | 	}
 67 | 
 68 | 	for {
 69 | 		node.UpdateScaleIOState()
 70 | 
 71 | 		self := node.GetSelfNode()
 72 | 		if self == nil {
 73 | 			log.Errorln("Unable to find Self in node list")
 74 | 			errState := node.UpdateNodeState(types.StateFatalInstall)
 75 | 			if errState != nil {
 76 | 				log.Errorln("Failed to signal state change:", errState)
 77 | 			} else {
 78 | 				log.Debugln("Signaled StateFatalInstall")
 79 | 			}
 80 | 			time.Sleep(time.Duration(common.PollAfterFatalInSeconds) * time.Second)
 81 | 			continue
 82 | 		}
 83 | 
 84 | 		switch self.State {
 85 | 		case types.StateUnknown:
 86 | 			node.RunStateUnknown()
 87 | 
 88 | 		case types.StateCleanPrereqsReboot:
 89 | 			node.RunStateCleanPrereqsReboot()
 90 | 
 91 | 		case types.StatePrerequisitesInstalled:
 92 | 			node.RunStatePrerequisitesInstalled()
 93 | 
 94 | 		case types.StateBasePackagedInstalled:
 95 | 			node.RunStateBasePackagedInstalled()
 96 | 
 97 | 		case types.StateInitializeCluster:
 98 | 			node.RunStateInitializeCluster()
 99 | 
100 | 		case types.StateInstallRexRay:
101 | 			node.RunStateInstallRexRay()
102 | 
103 | 		case types.StateAddResourcesToScaleIO:
104 | 			node.RunStateAddResourcesToScaleIO()
105 | 
106 | 		case types.StateCleanInstallReboot:
107 | 			node.RunStateCleanInstallReboot()
108 | 
109 | 		case types.StateSystemReboot:
110 | 			node.RunStateSystemReboot()
111 | 
112 | 		case types.StateFinishInstall:
113 | 			node.RunStateFinishInstall()
114 | 
115 | 		case types.StateUpgradeCluster:
116 | 			node.RunStateUpgradeCluster()
117 | 
118 | 		case types.StateFatalInstall:
119 | 			node.RunStateFatalInstall()
120 | 		}
121 | 	}
122 | 
123 | 	log.Infoln("RunExecutor Succeeded")
124 | 	log.Infoln("RunExecutor LEAVE")
125 | 	return nil
126 | }
127 | 


--------------------------------------------------------------------------------
/scaleio-executor/executor/scaleionodes/dataNode.go:
--------------------------------------------------------------------------------
  1 | package scaleionodes
  2 | 
  3 | import (
  4 | 	"time"
  5 | 
  6 | 	log "github.com/Sirupsen/logrus"
  7 | 	xplatform "github.com/dvonthenen/goxplatform"
  8 | 	xplatformsys "github.com/dvonthenen/goxplatform/sys"
  9 | 
 10 | 	config "github.com/codedellemc/scaleio-framework/scaleio-executor/config"
 11 | 	common "github.com/codedellemc/scaleio-framework/scaleio-executor/executor/common"
 12 | 	ubuntu14 "github.com/codedellemc/scaleio-framework/scaleio-executor/executor/pkgmgr/deb/ubuntu14"
 13 | 	mgr "github.com/codedellemc/scaleio-framework/scaleio-executor/executor/pkgmgr/mgr"
 14 | 	rhel7 "github.com/codedellemc/scaleio-framework/scaleio-executor/executor/pkgmgr/rpm/rhel7"
 15 | 	types "github.com/codedellemc/scaleio-framework/scaleio-scheduler/types"
 16 | )
 17 | 
 18 | //ScaleioDataNode implementation for ScaleIO Fake Node
 19 | type ScaleioDataNode struct {
 20 | 	common.ScaleioNode
 21 | 	PkgMgr mgr.INodeMgr
 22 | }
 23 | 
 24 | //NewData generates a Data Node object
 25 | func NewData(state *types.ScaleIOFramework, cfg *config.Config, getstate common.RetrieveState) *ScaleioDataNode {
 26 | 	myNode := &ScaleioDataNode{}
 27 | 	myNode.Config = cfg
 28 | 	myNode.GetState = getstate
 29 | 	myNode.RebootRequired = false
 30 | 
 31 | 	var pkgmgr mgr.INodeMgr
 32 | 	switch xplatform.GetInstance().Sys.GetOsType() {
 33 | 	case xplatformsys.OsRhel:
 34 | 		log.Infoln("Is RHEL7")
 35 | 		pkgmgr = rhel7.NewNodeRpmRhel7Mgr(state)
 36 | 	case xplatformsys.OsUbuntu:
 37 | 		log.Infoln("Is Ubuntu14")
 38 | 		pkgmgr = ubuntu14.NewNodeDebUbuntu14Mgr(state)
 39 | 	}
 40 | 	myNode.PkgMgr = pkgmgr
 41 | 
 42 | 	return myNode
 43 | }
 44 | 
 45 | //RunStateUnknown default action for StateUnknown
 46 | func (sdn *ScaleioDataNode) RunStateUnknown() {
 47 | 	reboot, err := sdn.PkgMgr.EnvironmentSetup(sdn.State)
 48 | 	if err != nil {
 49 | 		log.Errorln("EnvironmentSetup Failed:", err)
 50 | 		errState := sdn.UpdateNodeState(types.StateFatalInstall)
 51 | 		if errState != nil {
 52 | 			log.Errorln("Failed to signal state change:", errState)
 53 | 		} else {
 54 | 			log.Debugln("Signaled StateFatalInstall")
 55 | 		}
 56 | 		return
 57 | 	}
 58 | 
 59 | 	errState := sdn.UpdateNodeState(types.StateCleanPrereqsReboot)
 60 | 	if errState != nil {
 61 | 		log.Errorln("Failed to signal state change:", errState)
 62 | 	} else {
 63 | 		log.Debugln("Signaled StateCleanPrereqsReboot")
 64 | 	}
 65 | 
 66 | 	common.WaitForCleanPrereqsReboot(sdn)
 67 | 
 68 | 	errState = sdn.UpdateNodeState(types.StatePrerequisitesInstalled)
 69 | 	if errState != nil {
 70 | 		log.Errorln("Failed to signal state change:", errState)
 71 | 	} else {
 72 | 		log.Debugln("Signaled StatePrerequisitesInstalled")
 73 | 	}
 74 | 
 75 | 	//requires a reboot?
 76 | 	if reboot {
 77 | 		log.Infoln("Reboot required before StatePrerequisitesInstalled!")
 78 | 
 79 | 		if sdn.State.Debug {
 80 | 			log.Infoln("Skipping the reboot since Debug is TRUE")
 81 | 		} else {
 82 | 			ip1, err1 := xplatform.GetInstance().Nw.AutoDiscoverIP()
 83 | 			ip2, err2 := sdn.Config.ParseIPFromRestURI()
 84 | 
 85 | 			if err1 == nil && err2 == nil && ip1 == ip2 {
 86 | 				log.Infoln("Delay reboot host running the Scheduler")
 87 | 				time.Sleep(time.Duration(common.DelayForRebootInSeconds) * time.Second)
 88 | 			}
 89 | 
 90 | 			rebootErr := xplatform.GetInstance().Run.Command(common.RebootCmdline, common.RebootCheck, "")
 91 | 			if rebootErr != nil {
 92 | 				log.Errorln("Install Kernel Failed:", rebootErr)
 93 | 			}
 94 | 
 95 | 			time.Sleep(time.Duration(common.WaitForRebootInSeconds) * time.Second)
 96 | 		}
 97 | 	} else {
 98 | 		log.Infoln("No need to reboot while installing prerequisites")
 99 | 	}
100 | }
101 | 
102 | //RunStatePrerequisitesInstalled default action for StatePrerequisitesInstalled
103 | func (sdn *ScaleioDataNode) RunStatePrerequisitesInstalled() {
104 | 	err := sdn.PkgMgr.NodeSetup(sdn.State)
105 | 	if err != nil {
106 | 		log.Errorln("NodeSetup Failed:", err)
107 | 		errState := sdn.UpdateNodeState(types.StateFatalInstall)
108 | 		if errState != nil {
109 | 			log.Errorln("Failed to signal state change:", errState)
110 | 		} else {
111 | 			log.Debugln("Signaled StateFatalInstall")
112 | 		}
113 | 		return
114 | 	}
115 | 
116 | 	err = sdn.UpdateDevices()
117 | 	if err != nil {
118 | 		log.Errorln("UpdateDevices Failed:", err)
119 | 		errState := sdn.UpdateNodeState(types.StateFatalInstall)
120 | 		if errState != nil {
121 | 			log.Errorln("Failed to signal state change:", errState)
122 | 		} else {
123 | 			log.Debugln("Signaled StateFatalInstall")
124 | 		}
125 | 		return
126 | 	}
127 | 
128 | 	errState := sdn.UpdateNodeState(types.StateAddResourcesToScaleIO)
129 | 	if errState != nil {
130 | 		log.Errorln("Failed to signal state change:", errState)
131 | 	} else {
132 | 		log.Debugln("Signaled StateAddResourcesToScaleIO")
133 | 	}
134 | }
135 | 
136 | //RunStateInstallRexRay default action for StateInstallRexRay
137 | func (sdn *ScaleioDataNode) RunStateInstallRexRay() {
138 | 	reboot, err := sdn.PkgMgr.RexraySetup(sdn.State, sdn.Config.ExecutorID)
139 | 	if err != nil {
140 | 		log.Errorln("REX-Ray setup Failed:", err)
141 | 		errState := sdn.UpdateNodeState(types.StateFatalInstall)
142 | 		if errState != nil {
143 | 			log.Errorln("Failed to signal state change:", errState)
144 | 		} else {
145 | 			log.Debugln("Signaled StateFatalInstall")
146 | 		}
147 | 		return
148 | 	}
149 | 	sdn.RebootRequired = sdn.RebootRequired || reboot
150 | 
151 | 	err = sdn.PkgMgr.SetupIsolator(sdn.State)
152 | 	if err != nil {
153 | 		log.Errorln("Mesos Isolator setup Failed:", err)
154 | 		errState := sdn.UpdateNodeState(types.StateFatalInstall)
155 | 		if errState != nil {
156 | 			log.Errorln("Failed to signal state change:", errState)
157 | 		} else {
158 | 			log.Debugln("Signaled StateFatalInstall")
159 | 		}
160 | 		return
161 | 	}
162 | 
163 | 	errState := sdn.UpdateNodeState(types.StateCleanInstallReboot)
164 | 	if errState != nil {
165 | 		log.Errorln("Failed to signal state change:", errState)
166 | 	} else {
167 | 		log.Debugln("Signaled StateCleanInstallReboot")
168 | 	}
169 | 
170 | 	common.WaitForCleanInstallReboot(sdn)
171 | 
172 | 	//requires a reboot?
173 | 	if sdn.RebootRequired {
174 | 		log.Infoln("Reboot required before StateFinishInstall!")
175 | 		log.Debugln("reboot:", sdn.RebootRequired)
176 | 
177 | 		errState := sdn.UpdateNodeState(types.StateSystemReboot)
178 | 		if errState != nil {
179 | 			log.Errorln("Failed to signal state change:", errState)
180 | 		} else {
181 | 			log.Debugln("Signaled StateSystemReboot")
182 | 		}
183 | 
184 | 		if sdn.State.Debug {
185 | 			log.Infoln("Skipping the reboot since Debug is TRUE")
186 | 		} else {
187 | 			ip1, err1 := xplatform.GetInstance().Nw.AutoDiscoverIP()
188 | 			ip2, err2 := sdn.Config.ParseIPFromRestURI()
189 | 
190 | 			if err1 == nil && err2 == nil && ip1 == ip2 {
191 | 				log.Infoln("Delay reboot host running the Scheduler")
192 | 				time.Sleep(time.Duration(common.DelayForRebootInSeconds) * time.Second)
193 | 			}
194 | 
195 | 			rebootErr := xplatform.GetInstance().Run.Command(common.RebootCmdline, common.RebootCheck, "")
196 | 			if rebootErr != nil {
197 | 				log.Errorln("Install Kernel Failed:", rebootErr)
198 | 			}
199 | 
200 | 			time.Sleep(time.Duration(common.WaitForRebootInSeconds) * time.Second)
201 | 		}
202 | 	} else {
203 | 		log.Infoln("No need to reboot while installing REX-Ray")
204 | 
205 | 		errState := sdn.UpdateNodeState(types.StateFinishInstall)
206 | 		if errState != nil {
207 | 			log.Errorln("Failed to signal state change:", errState)
208 | 		} else {
209 | 			log.Debugln("Signaled StateFinishInstall")
210 | 		}
211 | 	}
212 | }
213 | 
214 | //RunStateSystemReboot default action for StateSystemReboot
215 | func (sdn *ScaleioDataNode) RunStateSystemReboot() {
216 | 	errState := sdn.UpdateNodeState(types.StateFinishInstall)
217 | 	if errState != nil {
218 | 		log.Errorln("Failed to signal state change:", errState)
219 | 	} else {
220 | 		log.Debugln("Signaled StateFinishInstall")
221 | 	}
222 | }
223 | 
224 | //RunStateFinishInstall default action for StateFinishInstall
225 | func (sdn *ScaleioDataNode) RunStateFinishInstall() {
226 | 	node := sdn.GetSelfNode()
227 | 	if !node.Imperative && !node.Advertised {
228 | 		err := sdn.UpdateDevices()
229 | 		if err == nil {
230 | 			log.Infoln("UpdateDevices() Succcedeed. Devices advertised!")
231 | 		} else {
232 | 			log.Errorln("UpdateDevices() Failed. Err:", err)
233 | 		}
234 | 	}
235 | 
236 | 	log.Debugln("In StateFinishInstall. Wait for", common.PollForChangesInSeconds,
237 | 		"seconds for changes in the cluster.")
238 | 	time.Sleep(time.Duration(common.PollForChangesInSeconds) * time.Second)
239 | }
240 | 
241 | //RunStateUpgradeCluster default action for StateUpgradeCluster
242 | func (sdn *ScaleioDataNode) RunStateUpgradeCluster() {
243 | 	log.Debugln("In StateUpgradeCluster. Do nothing.")
244 | 	//TODO process the upgrade here
245 | }
246 | 


--------------------------------------------------------------------------------
/scaleio-executor/glide.yaml:
--------------------------------------------------------------------------------
 1 | package: github.com/codedellemc/scaleio-framework/scaleio-executor
 2 | import:
 3 | - package: github.com/Sirupsen/logrus
 4 |   ref:     v0.10.0
 5 |   vcs:     git
 6 | - package: github.com/stretchr/testify
 7 |   ref:     v1.1.3
 8 |   vcs:     git
 9 | - package: github.com/twinj/uuid
10 |   vcs:     git
11 | - package: github.com/dvonthenen/goxplatform
12 |   vcs:     git
13 | 


--------------------------------------------------------------------------------
/scaleio-executor/glide.yaml.dev:
--------------------------------------------------------------------------------
 1 | package: github.com/codedellemc/scaleio-framework/scaleio-executor
 2 | import:
 3 | - package: github.com/Sirupsen/logrus
 4 |   ref:     v0.10.0
 5 |   vcs:     git
 6 | - package: github.com/stretchr/testify
 7 |   ref:     v1.1.3
 8 |   vcs:     git
 9 | - package: github.com/twinj/uuid
10 |   vcs:     git
11 | - package: github.com/dvonthenen/goxplatform
12 |   vcs:     git
13 |   
14 | - package: github.com/codedellemc/scaleio-framework
15 |   ref:     ebb9d9318186cf78f880b57a805318edb381b5cb
16 |   vcs:     git
17 |   repo:    https://github.com/dvonthenen/scaleio-framework


--------------------------------------------------------------------------------
/scaleio-executor/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"flag"
 5 | 	"math/rand"
 6 | 	"os"
 7 | 	"strings"
 8 | 	"time"
 9 | 
10 | 	log "github.com/Sirupsen/logrus"
11 | 
12 | 	config "github.com/codedellemc/scaleio-framework/scaleio-executor/config"
13 | 	executor "github.com/codedellemc/scaleio-framework/scaleio-executor/executor"
14 | )
15 | 
16 | // ----------------------- func init() ------------------------- //
17 | 
18 | func init() {
19 | 	rand.Seed(time.Now().UnixNano())
20 | 	log.SetOutput(os.Stdout)
21 | 	log.Info("Initializing the ScaleIO Executor...")
22 | }
23 | 
24 | func main() {
25 | 	for _, e := range os.Environ() {
26 | 		pair := strings.Split(e, "=")
27 | 		log.Debugln(pair[0], "=", pair[1])
28 | 	}
29 | 
30 | 	cfg := config.NewConfig()
31 | 	fs := flag.NewFlagSet("executor", flag.ExitOnError)
32 | 	cfg.AddFlags(fs)
33 | 	fs.Parse(os.Args[1:])
34 | 
35 | 	level, err := log.ParseLevel(cfg.LogLevel)
36 | 	if err != nil {
37 | 		log.Warnln("Invalid log level. Defaulting to info.")
38 | 		level = log.InfoLevel
39 | 	} else {
40 | 		log.Infoln("Set logging to", cfg.LogLevel)
41 | 	}
42 | 	log.SetLevel(level)
43 | 
44 | 	log.Infoln("ExecutorID:", cfg.ExecutorID)
45 | 	log.Infoln("FrameworkID:", cfg.FrameworkID)
46 | 	log.Infoln("MesosAgent:", cfg.MesosAgent)
47 | 	log.Infoln("RestURI:", cfg.SchedulerURI)
48 | 
49 | 	exec := executor.NewScaleIOExecutor(cfg)
50 | 	log.Debugln("Starting ScaleIO Executor")
51 | 	<-exec.Start()
52 | 	log.Info("Executor terminating")
53 | }
54 | 


--------------------------------------------------------------------------------
/scaleio-executor/mesos/exec/executor.proto:
--------------------------------------------------------------------------------
  1 | // Licensed to the Apache Software Foundation (ASF) under one
  2 | // or more contributor license agreements.  See the NOTICE file
  3 | // distributed with this work for additional information
  4 | // regarding copyright ownership.  The ASF licenses this file
  5 | // to you under the Apache License, Version 2.0 (the
  6 | // "License"); you may not use this file except in compliance
  7 | // with the License.  You may obtain a copy of the License at
  8 | //
  9 | //     http://www.apache.org/licenses/LICENSE-2.0
 10 | //
 11 | // Unless required by applicable law or agreed to in writing, software
 12 | // distributed under the License is distributed on an "AS IS" BASIS,
 13 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 14 | // See the License for the specific language governing permissions and
 15 | // limitations under the License.
 16 | 
 17 | import "github.com/dvonthenen/scaleio-executor/mesos/v1/mesos.proto";
 18 | 
 19 | package mesos.v1.executor;
 20 | 
 21 | option java_package = "org.apache.mesos.v1.executor";
 22 | option java_outer_classname = "Protos";
 23 | 
 24 | 
 25 | /**
 26 |  * Executor event API.
 27 |  *
 28 |  * An event is described using the standard protocol buffer "union"
 29 |  * trick, see https://developers.google.com/protocol-buffers/docs/techniques#union.
 30 |  */
 31 | message Event {
 32 |   // Possible event types, followed by message definitions if
 33 |   // applicable.
 34 |   enum Type {
 35 |     // This must be the first enum value in this list, to
 36 |     // ensure that if 'type' is not set, the default value
 37 |     // is UNKNOWN. This enables enum values to be added
 38 |     // in a backwards-compatible way. See: MESOS-4997.
 39 |     UNKNOWN = 0;
 40 | 
 41 |     SUBSCRIBED = 1;   // See 'Subscribed' below.
 42 |     LAUNCH = 2;       // See 'Launch' below.
 43 |     KILL = 3;         // See 'Kill' below.
 44 |     ACKNOWLEDGED = 4; // See 'Acknowledged' below.
 45 |     MESSAGE = 5;      // See 'Message' below.
 46 |     ERROR = 6;        // See 'Error' below.
 47 | 
 48 |     // Received when the agent asks the executor to shutdown/kill itself.
 49 |     // The executor is then required to kill all its active tasks, send
 50 |     // `TASK_KILLED` status updates and gracefully exit. The executor
 51 |     // should terminate within a `MESOS_EXECUTOR_SHUTDOWN_GRACE_PERIOD`
 52 |     // (an environment variable set by the agent upon executor startup);
 53 |     // it can be configured via `ExecutorInfo.shutdown_grace_period`. If
 54 |     // the executor fails to do so, the agent will forcefully destroy the
 55 |     // container where the executor is running. The agent would then send
 56 |     // `TASK_LOST` updates for any remaining active tasks of this executor.
 57 |     //
 58 |     // NOTE: The executor must not assume that it will always be allotted
 59 |     // the full grace period, as the agent may decide to allot a shorter
 60 |     // period and failures / forcible terminations may occur.
 61 |     //
 62 |     // TODO(alexr): Consider adding a duration field into the `Shutdown`
 63 |     // message so that the agent can communicate when a shorter period
 64 |     // has been allotted.
 65 |     SHUTDOWN = 7;
 66 |   }
 67 | 
 68 |   // First event received when the executor subscribes.
 69 |   // The 'id' field in the 'framework_info' will be set.
 70 |    message Subscribed {
 71 |     required ExecutorInfo executor_info = 1;
 72 |     required FrameworkInfo framework_info = 2;
 73 |     required AgentInfo agent_info = 3;
 74 |   }
 75 | 
 76 |   // Received when the framework attempts to launch a task. Once
 77 |   // the task is successfully launched, the executor must respond with
 78 |   // a TASK_RUNNING update (See TaskState in v1/mesos.proto).
 79 |   message Launch {
 80 |     required TaskInfo task = 1;
 81 |   }
 82 | 
 83 |   // Received when the scheduler wants to kill a specific task. Once
 84 |   // the task is terminated, the executor should send a TASK_KILLED
 85 |   // (or TASK_FAILED) update. The terminal update is necessary so
 86 |   // Mesos can release the resources associated with the task.
 87 |   message Kill {
 88 |     required TaskID task_id = 1;
 89 | 
 90 |     // If set, overrides any previously specified kill policy for this task.
 91 |     // This includes 'TaskInfo.kill_policy' and 'Executor.kill.kill_policy'.
 92 |     // Can be used to forcefully kill a task which is already being killed.
 93 |     optional KillPolicy kill_policy = 2;
 94 |   }
 95 | 
 96 |   // Received when the agent acknowledges the receipt of status
 97 |   // update. Schedulers are responsible for explicitly acknowledging
 98 |   // the receipt of status updates that have 'update.status().uuid()'
 99 |   // field set. Unacknowledged updates can be retried by the executor.
100 |   // They should also be sent by the executor whenever it
101 |   // re-subscribes.
102 |   message Acknowledged {
103 |     required TaskID task_id = 1;
104 |     required bytes uuid = 2;
105 |   }
106 | 
107 |   // Received when a custom message generated by the scheduler is
108 |   // forwarded by the agent. Note that this message is not
109 |   // interpreted by Mesos and is only forwarded (without reliability
110 |   // guarantees) to the executor. It is up to the scheduler to retry
111 |   // if the message is dropped for any reason.
112 |   message Message {
113 |     required bytes data = 1;
114 |   }
115 | 
116 |   // Received in case the executor sends invalid calls (e.g.,
117 |   // required values not set).
118 |   // TODO(arojas): Remove this once the old executor driver is no
119 |   // longer supported. With HTTP API all errors will be signaled via
120 |   // HTTP response codes.
121 |   message Error {
122 |     required string message = 1;
123 |   }
124 | 
125 |   // Type of the event, indicates which optional field below should be
126 |   // present if that type has a nested message definition.
127 |   // Enum fields should be optional, see: MESOS-4997.
128 |   optional Type type = 1;
129 | 
130 |   optional Subscribed subscribed = 2;
131 |   optional Acknowledged acknowledged = 3;
132 |   optional Launch launch = 4;
133 |   optional Kill kill = 5;
134 |   optional Message message = 6;
135 |   optional Error error = 7;
136 | }
137 | 
138 | 
139 | /**
140 |  * Executor call API.
141 |  *
142 |  * Like Event, a Call is described using the standard protocol buffer
143 |  * "union" trick (see above).
144 |  */
145 |  message Call {
146 |   // Possible call types, followed by message definitions if
147 |   // applicable.
148 |   enum Type {
149 |     // See comments above on `Event::Type` for more details on this enum value.
150 |     UNKNOWN = 0;
151 | 
152 |     SUBSCRIBE = 1;    // See 'Subscribe' below.
153 |     UPDATE = 2;       // See 'Update' below.
154 |     MESSAGE = 3;      // See 'Message' below.
155 |   }
156 | 
157 |   // Request to subscribe with the agent. If subscribing after a disconnection,
158 |   // it must include a list of all the tasks and updates which haven't been
159 |   // acknowledged by the scheduler.
160 |   message Subscribe {
161 |     repeated TaskInfo unacknowledged_tasks = 1;
162 |     repeated Update unacknowledged_updates = 2;
163 |   }
164 | 
165 |   // Notifies the scheduler that a task has transitioned from one
166 |   // state to another. Status updates should be used by executors
167 |   // to reliably communicate the status of the tasks that they
168 |   // manage. It is crucial that a terminal update (see TaskState
169 |   // in v1/mesos.proto) is sent to the scheduler as soon as the task
170 |   // terminates, in order for Mesos to release the resources allocated
171 |   // to the task. It is the responsibility of the scheduler to
172 |   // explicitly acknowledge the receipt of a status update. See
173 |   // 'Acknowledged' in the 'Events' section above for the semantics.
174 |   message Update {
175 |     required TaskStatus status = 1;
176 |   }
177 | 
178 |   // Sends arbitrary binary data to the scheduler. Note that Mesos
179 |   // neither interprets this data nor makes any guarantees about the
180 |   // delivery of this message to the scheduler.
181 |   // See 'Message' in the 'Events' section.
182 |   message Message {
183 |     required bytes data = 2;
184 |   }
185 | 
186 |   // Identifies the executor which generated this call.
187 |   required ExecutorID executor_id = 1;
188 |   required FrameworkID framework_id = 2;
189 | 
190 |   // Type of the call, indicates which optional field below should be
191 |   // present if that type has a nested message definition.
192 |   // In case type is SUBSCRIBED, no message needs to be set.
193 |   // See comments on `Event::Type` above on the reasoning behind this field being optional.
194 |   optional Type type = 3;
195 | 
196 |   optional Subscribe subscribe = 4;
197 |   optional Update update = 5;
198 |   optional Message message = 6;
199 | }
200 | 


--------------------------------------------------------------------------------
/scaleio-executor/protoc.sh:
--------------------------------------------------------------------------------
1 | protoc  --proto_path=$GOPATH/src:.  --go_out=. ./mesos/v1/mesos.proto
2 | protoc  --proto_path=$GOPATH/src:.  --go_out=. ./mesos/exec/executor.proto
3 | 


--------------------------------------------------------------------------------
/scaleio-executor/switch.sh:
--------------------------------------------------------------------------------
 1 | #! /usr/bin/env bash
 2 | 
 3 | if [ "$1" == "which" ]; then
 4 |     if [ -f glide.yaml.dev ]; then
 5 |         echo "Building PROD"
 6 |     elif [ -f glide.yaml.org ]; then
 7 |         echo "Building DEV"
 8 |     fi
 9 | elif [ -f glide.yaml.dev ]; then
10 |     echo "Enabling DEV"
11 |     mv glide.yaml glide.yaml.org
12 |     mv glide.yaml.dev glide.yaml
13 | elif [ -f glide.yaml.org ]; then
14 |     echo "Enabling PROD"
15 |     mv glide.yaml glide.yaml.dev
16 |     mv glide.yaml.org glide.yaml
17 | fi


--------------------------------------------------------------------------------
/scaleio-scheduler/build.sh:
--------------------------------------------------------------------------------
 1 | #! /usr/bin/env bash
 2 | 
 3 | rm -rf ./vendor
 4 | rm glide.lock
 5 | rm ./scaleio-scheduler
 6 | glide up
 7 | 
 8 | grep -R --exclude-dir vendor --exclude-dir .git --exclude-dir mesos --exclude build.sh TODO ./
 9 | 
10 | GOOS=linux GOARCH=amd64 go build .
11 | 


--------------------------------------------------------------------------------
/scaleio-scheduler/client/http.go:
--------------------------------------------------------------------------------
  1 | package client
  2 | 
  3 | import (
  4 | 	"bytes"
  5 | 	"errors"
  6 | 	"fmt"
  7 | 	"net"
  8 | 	"net/http"
  9 | 	"strings"
 10 | 	"time"
 11 | 
 12 | 	log "github.com/Sirupsen/logrus"
 13 | 	xplatform "github.com/dvonthenen/goxplatform"
 14 | )
 15 | 
 16 | const (
 17 | 	defaultReadTimeout  = 10 * time.Second
 18 | 	defaultWriteTimeout = 10 * time.Second
 19 | )
 20 | 
 21 | //Client representation of an HTTP client
 22 | type Client struct {
 23 | 	streamID   string
 24 | 	url        string
 25 | 	masterAddr string
 26 | 	masterPath string
 27 | 	client     *http.Client
 28 | }
 29 | 
 30 | //New generates a new HTTP client
 31 | func New(addr string, path string) *Client {
 32 | 	return &Client{
 33 | 		url:        "http://" + addr + path,
 34 | 		masterAddr: addr,
 35 | 		masterPath: path,
 36 | 		client: &http.Client{
 37 | 			Transport: &http.Transport{
 38 | 				Dial: (&net.Dialer{
 39 | 					Timeout:   10 * time.Second,
 40 | 					KeepAlive: 30 * time.Second,
 41 | 				}).Dial,
 42 | 			},
 43 | 		},
 44 | 	}
 45 | }
 46 | 
 47 | func parsePartialURI(str string) (string, string) {
 48 | 	str = xplatform.GetInstance().Str.Trim(str, " /")
 49 | 	index := strings.Index(str, "/")
 50 | 	master := str[:index]
 51 | 	path := str[index:]
 52 | 	return master, path
 53 | }
 54 | 
 55 | //Send will send a HTTP payload to an HTTP server
 56 | func (c *Client) Send(payload []byte) (*http.Response, error) {
 57 | 	httpReq, err := http.NewRequest("POST", c.url, bytes.NewReader(payload))
 58 | 	if err != nil {
 59 | 		return nil, err
 60 | 	}
 61 | 
 62 | 	httpReq.Header.Set("Content-Type", "application/x-protobuf")
 63 | 	httpReq.Header.Set("Accept", "application/json") //TODO switch to protobuf at some point
 64 | 	httpReq.Header.Set("User-Agent", "scaleio/0.1")
 65 | 	if c.streamID != "" {
 66 | 		httpReq.Header.Set("Mesos-Stream-Id", c.streamID)
 67 | 	}
 68 | 
 69 | 	httpResp, err := c.client.Do(httpReq)
 70 | 	if err != nil {
 71 | 		log.Errorln("HTTP ERROR:", err)
 72 | 		return nil, err
 73 | 	}
 74 | 
 75 | 	if httpResp.StatusCode == http.StatusTemporaryRedirect ||
 76 | 		httpResp.StatusCode == http.StatusPermanentRedirect {
 77 | 		log.Warnln("Old Master:", c.masterAddr)
 78 | 		master, path := parsePartialURI(httpResp.Header.Get("Location"))
 79 | 		c.masterAddr = master
 80 | 		c.masterPath = path
 81 | 		log.Warnln("New Master:", c.masterAddr)
 82 | 		c.url = "http://" + c.masterAddr + c.masterPath
 83 | 		log.Warnln("New URL:", c.url)
 84 | 		msg := fmt.Sprint("StatusRedirect - New master is: ", c.masterAddr)
 85 | 		log.Errorln(msg)
 86 | 		return nil, errors.New(msg)
 87 | 	}
 88 | 
 89 | 	streamID := httpResp.Header.Get("Mesos-Stream-Id")
 90 | 	if streamID != "" {
 91 | 		if c.streamID == "" {
 92 | 			log.Infoln("[MESOS-STREAM-ID] Setting to", streamID)
 93 | 		} else {
 94 | 			log.Infoln("[MESOS-STREAM-ID]", c.streamID, "->", streamID)
 95 | 		}
 96 | 		c.streamID = streamID
 97 | 	}
 98 | 	return httpResp, nil
 99 | }
100 | 


--------------------------------------------------------------------------------
/scaleio-scheduler/config/env.go:
--------------------------------------------------------------------------------
 1 | package config
 2 | 
 3 | import (
 4 | 	"os"
 5 | 	"os/user"
 6 | 	"strconv"
 7 | 	"time"
 8 | 
 9 | 	log "github.com/Sirupsen/logrus"
10 | )
11 | 
12 | func env(key, defaultValue string) (value string) {
13 | 	if value = os.Getenv(key); value == "" {
14 | 		value = defaultValue
15 | 	}
16 | 	return
17 | }
18 | 
19 | func envInt(key, defaultValue string) int {
20 | 	value, err := strconv.Atoi(env(key, defaultValue))
21 | 	if err != nil {
22 | 		panic(err.Error())
23 | 	}
24 | 	return value
25 | }
26 | 
27 | func envBool(key, defaultValue string) bool {
28 | 	return env(key, defaultValue) == "true"
29 | }
30 | 
31 | func envDuration(key, defaultValue string) time.Duration {
32 | 	value, err := time.ParseDuration(env(key, defaultValue))
33 | 	if err != nil {
34 | 		panic(err.Error())
35 | 	}
36 | 	return value
37 | }
38 | 
39 | func envFloat(key, defaultValue string) float64 {
40 | 	value, err := strconv.ParseFloat(env(key, defaultValue), 64)
41 | 	if err != nil {
42 | 		panic(err.Error())
43 | 	}
44 | 	return value
45 | }
46 | 
47 | func mesosUser() string {
48 | 	u, err := user.Current()
49 | 	if err != nil {
50 | 		log.Warnln("Unable to determine user")
51 | 		return "root"
52 | 	}
53 | 
54 | 	log.Debugln("User:", u.Username)
55 | 	return u.Username
56 | }
57 | 
58 | func mesosHostname() string {
59 | 	hostname, err := os.Hostname()
60 | 	if err != nil {
61 | 		log.Errorln("Unable to determine Hostname")
62 | 		return "UNKNOWN"
63 | 	}
64 | 	log.Debugln("Hostname:", hostname)
65 | 	return hostname
66 | }
67 | 


--------------------------------------------------------------------------------
/scaleio-scheduler/glide.yaml:
--------------------------------------------------------------------------------
 1 | package: github.com/codedellemc/scaleio-framework/scaleio-scheduler
 2 | import:
 3 | - package: github.com/Sirupsen/logrus
 4 |   ref:     v0.10.0
 5 |   vcs:     git
 6 | - package: github.com/stretchr/testify
 7 |   ref:     v1.1.3
 8 |   vcs:     git
 9 | - package: github.com/dvonthenen/goxplatform
10 |   vcs:     git
11 | 
12 | - package: github.com/docker/libkv
13 | - package: github.com/boltdb/bolt
14 |   ref:     v1.3.0
15 | - package: github.com/coreos/etcd/client
16 |   ref:     v3.0.14
17 | - package: github.com/samuel/go-zookeeper/zk
18 |   ref:     1d7be4effb13d2d908342d349d71a284a7542693
19 | - package: github.com/hashicorp/consul/api
20 |   ref:     v0.7.1
21 | 
22 | - package: github.com/codedellemc/goscaleio
23 |   vcs:     git


--------------------------------------------------------------------------------
/scaleio-scheduler/glide.yaml.dev:
--------------------------------------------------------------------------------
 1 | package: github.com/codedellemc/scaleio-framework/scaleio-scheduler
 2 | import:
 3 | - package: github.com/Sirupsen/logrus
 4 |   ref:     v0.10.0
 5 |   vcs:     git
 6 | - package: github.com/stretchr/testify
 7 |   ref:     v1.1.3
 8 |   vcs:     git
 9 | - package: github.com/dvonthenen/goxplatform
10 |   vcs:     git
11 | 
12 | - package: github.com/docker/libkv
13 | - package: github.com/boltdb/bolt
14 |   ref:     v1.3.0
15 | - package: github.com/coreos/etcd/client
16 |   ref:     v3.0.14
17 | - package: github.com/samuel/go-zookeeper/zk
18 |   ref:     1d7be4effb13d2d908342d349d71a284a7542693
19 | - package: github.com/hashicorp/consul/api
20 |   ref:     v0.7.1
21 | - package: github.com/aws/aws-sdk-go
22 |   ref:     v1.6.13
23 | 
24 | - package: github.com/codedellemc/goscaleio
25 |   vcs:     git
26 | - package: github.com/codedellemc/scaleio-framework
27 |   ref:     ebb9d9318186cf78f880b57a805318edb381b5cb
28 |   vcs:     git
29 |   repo:    https://github.com/dvonthenen/scaleio-framework


--------------------------------------------------------------------------------
/scaleio-scheduler/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"flag"
 5 | 	"math/rand"
 6 | 	"os"
 7 | 	"strings"
 8 | 	"time"
 9 | 
10 | 	log "github.com/Sirupsen/logrus"
11 | 
12 | 	"github.com/codedellemc/scaleio-framework/scaleio-scheduler/config"
13 | 	"github.com/codedellemc/scaleio-framework/scaleio-scheduler/scheduler"
14 | )
15 | 
16 | // ----------------------- func init() ------------------------- //
17 | 
18 | func init() {
19 | 	rand.Seed(time.Now().UnixNano())
20 | 	log.SetOutput(os.Stdout)
21 | 	log.Infoln("Initializing the ScaleIO Scheduler...")
22 | }
23 | 
24 | func prerequisites(cfg *config.Config) bool {
25 | 	if !cfg.Experimental && (cfg.PrimaryMdmAddress == "" &&
26 | 		cfg.SecondaryMdmAddress == "" && cfg.TieBreakerMdmAddress == "") {
27 | 		log.Errorln("Primary, Secondary and TieBreaker MDM nodes must be pre-configured" +
28 | 			"in order for additional nodes to be added to the ScaleIO cluster.")
29 | 		return false
30 | 	}
31 | 
32 | 	if (cfg.PrimaryMdmAddress != "" && cfg.SecondaryMdmAddress != "" &&
33 | 		cfg.TieBreakerMdmAddress != "") || (cfg.PrimaryMdmAddress == "" &&
34 | 		cfg.SecondaryMdmAddress == "" && cfg.TieBreakerMdmAddress == "") {
35 | 		return true
36 | 	}
37 | 
38 | 	if cfg.PrimaryMdmAddress != "" {
39 | 		log.Errorln("A Pre-Configured Primary MDM IP Address was provided. " +
40 | 			"Using this option requires that a Pre-Configured Primary and TieBreaker MDM " +
41 | 			"Nodes exist and their IP addresses be provided via command line option.")
42 | 	} else if cfg.SecondaryMdmAddress != "" {
43 | 		log.Errorln("A Pre-Configured Secondary MDM IP Address was provided. " +
44 | 			"Using this option requires that a Pre-Configured Primary and TieBreaker MDM " +
45 | 			"Nodes exist and their IP addresses be provided via command line option.")
46 | 	} else if cfg.TieBreakerMdmAddress != "" {
47 | 		log.Errorln("A Pre-Configured TieBreaker MDM IP Address was provided. " +
48 | 			"Using this option requires that a Pre-Configured Primary and Secondary MDM " +
49 | 			"Nodes exist and their IP addresses be provided via command line option.")
50 | 	}
51 | 	return false
52 | }
53 | 
54 | func main() {
55 | 	for _, e := range os.Environ() {
56 | 		pair := strings.Split(e, "=")
57 | 		log.Debugln(pair[0], "=", pair[1])
58 | 	}
59 | 
60 | 	cfg := config.NewConfig()
61 | 	fs := flag.NewFlagSet("scheduler", flag.ExitOnError)
62 | 	cfg.AddFlags(fs)
63 | 	fs.Parse(os.Args[1:])
64 | 
65 | 	level, err := log.ParseLevel(cfg.LogLevel)
66 | 	if err != nil {
67 | 		log.Warnln("Invalid log level. Defaulting to info.")
68 | 		level = log.InfoLevel
69 | 	} else {
70 | 		log.Infoln("Set logging to", cfg.LogLevel)
71 | 	}
72 | 	log.SetLevel(level)
73 | 
74 | 	if !prerequisites(cfg) {
75 | 		return //prerequisites not met
76 | 	}
77 | 
78 | 	sched := scheduler.NewScaleIOScheduler(cfg)
79 | 	if sched == nil {
80 | 		log.Fatalln("Scheduler is nil")
81 | 		return
82 | 	}
83 | 	log.Debugln("Starting ScaleIO Scheduler")
84 | 	<-sched.Start()
85 | 	log.Debugln("Scheduler terminating")
86 | }
87 | 


--------------------------------------------------------------------------------
/scaleio-scheduler/protoc.sh:
--------------------------------------------------------------------------------
1 | protoc  --proto_path=$GOPATH/src:. --go_out=. ./mesos/v1/mesos.proto
2 | protoc  --proto_path=$GOPATH/src:. --go_out=. ./mesos/sched/scheduler.proto
3 | 


--------------------------------------------------------------------------------
/scaleio-scheduler/scheduler/common/common.go:
--------------------------------------------------------------------------------
  1 | package common
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 
  6 | 	log "github.com/Sirupsen/logrus"
  7 | 
  8 | 	types "github.com/codedellemc/scaleio-framework/scaleio-scheduler/types"
  9 | )
 10 | 
 11 | var (
 12 | 	//ErrNodeNotFound The node was not found
 13 | 	ErrNodeNotFound = errors.New("The node was not found")
 14 | 
 15 | 	//ErrAttributeNotFound The attribute was not found
 16 | 	ErrAttributeNotFound = errors.New("The attribute was not found")
 17 | )
 18 | 
 19 | //PersonaStringToID String -> PersonaID
 20 | func PersonaStringToID(persona string) int {
 21 | 	switch persona {
 22 | 	case "primary":
 23 | 		return types.PersonaMdmPrimary
 24 | 	case "secondary":
 25 | 		return types.PersonaMdmSecondary
 26 | 	case "tiebreaker":
 27 | 		return types.PersonaTb
 28 | 	case "data":
 29 | 		return types.PersonaNode
 30 | 	default:
 31 | 		return types.PersonaUnknown
 32 | 	}
 33 | }
 34 | 
 35 | //PersonaIDToString PersonaID -> String
 36 | func PersonaIDToString(persona int) string {
 37 | 	switch persona {
 38 | 	case types.PersonaMdmPrimary:
 39 | 		return "primary"
 40 | 	case types.PersonaMdmSecondary:
 41 | 		return "secondary"
 42 | 	case types.PersonaTb:
 43 | 		return "tiebreaker"
 44 | 	case types.PersonaNode:
 45 | 		return "data"
 46 | 	default:
 47 | 		return "unknown"
 48 | 	}
 49 | }
 50 | 
 51 | //FindScaleIONodeByHostname Find ScaleIO node by Hostname
 52 | func FindScaleIONodeByHostname(nodes []*types.ScaleIONode, hostname string) *types.ScaleIONode {
 53 | 	log.Debugln("FindScaleIONodeByHostname ENTER")
 54 | 	log.Debugln("hostname:", hostname)
 55 | 
 56 | 	if len(hostname) == 0 {
 57 | 		log.Debugln("Hostname is empty. Return nil.")
 58 | 		log.Debugln("FindScaleIONodeByHostname LEAVE")
 59 | 		return nil
 60 | 	}
 61 | 
 62 | 	for i := 0; i < len(nodes); i++ {
 63 | 		node := nodes[i]
 64 | 		log.Debugln(node.Hostname, "=", hostname, "?")
 65 | 		if node.Hostname == hostname {
 66 | 			log.Debugln("Node Found")
 67 | 			log.Debugln("FindScaleIONodeByHostname LEAVE")
 68 | 			return node
 69 | 		}
 70 | 	}
 71 | 
 72 | 	log.Debugln("Node NOT Found")
 73 | 	log.Debugln("FindScaleIONodeByHostname LEAVE")
 74 | 	return nil
 75 | }
 76 | 
 77 | //FindScaleIONodeByExecutorID Get ScaleIO node by ExecutorID
 78 | func FindScaleIONodeByExecutorID(nodes []*types.ScaleIONode, executorID string) *types.ScaleIONode {
 79 | 	log.Debugln("FindScaleIONodeByExecutorID ENTER")
 80 | 	log.Debugln("executorID:", executorID)
 81 | 
 82 | 	for i := 0; i < len(nodes); i++ {
 83 | 		node := nodes[i]
 84 | 		log.Debugln(node.ExecutorID, "=", executorID, "?")
 85 | 		if node.ExecutorID == executorID {
 86 | 			log.Debugln("Node Found:", node.ExecutorID)
 87 | 			log.Debugln("FindScaleIONodeByExecutorID LEAVE")
 88 | 			return node
 89 | 		}
 90 | 	}
 91 | 
 92 | 	log.Debugln("Node NOT Found")
 93 | 	log.Debugln("FindScaleIONodeByExecutorID LEAVE")
 94 | 	return nil
 95 | }
 96 | 
 97 | func getNodeType(state *types.ScaleIOFramework, nodeType int) (*types.ScaleIONode, error) {
 98 | 	for _, node := range state.ScaleIO.Nodes {
 99 | 		if node.Persona == nodeType {
100 | 			log.Infoln("Found MDM Node:", node.ExecutorID, "Persona:", node.Persona)
101 | 			return node, nil
102 | 		}
103 | 	}
104 | 	return nil, ErrNodeNotFound
105 | }
106 | 
107 | //GetPrimaryMdmNode gets the Primary node
108 | func GetPrimaryMdmNode(state *types.ScaleIOFramework) (*types.ScaleIONode, error) {
109 | 	return getNodeType(state, types.PersonaMdmPrimary)
110 | }
111 | 
112 | //GetGatewayAddress returns the ScaleIO gateway address
113 | func GetGatewayAddress(state *types.ScaleIOFramework) (string, error) {
114 | 	if state.ScaleIO.Preconfig.PreConfigEnabled &&
115 | 		state.ScaleIO.Preconfig.GatewayAddress != "" {
116 | 		log.Debugln("Using Pre-Configured Gateway:",
117 | 			state.ScaleIO.Preconfig.GatewayAddress)
118 | 		return state.ScaleIO.Preconfig.GatewayAddress, nil
119 | 	} else if state.ScaleIO.Preconfig.PreConfigEnabled {
120 | 		log.Debugln("Pre-Configured Gateway Not Set:",
121 | 			state.ScaleIO.Preconfig.PrimaryMdmAddress)
122 | 		return state.ScaleIO.Preconfig.PrimaryMdmAddress, nil
123 | 	} else if state.ScaleIO.LbGateway != "" {
124 | 		log.Debugln("Using Load Balancing Gateway:",
125 | 			state.ScaleIO.LbGateway)
126 | 		return state.ScaleIO.LbGateway, nil
127 | 	}
128 | 
129 | 	pri, err := GetPrimaryMdmNode(state)
130 | 	if err != nil {
131 | 		log.Errorln("Unable to find the Primary MDM node")
132 | 		return "", err
133 | 	}
134 | 
135 | 	log.Debugln("Determined Gateway:", pri.IPAddress)
136 | 	return pri.IPAddress, nil
137 | }
138 | 


--------------------------------------------------------------------------------
/scaleio-scheduler/scheduler/common/waitstates.go:
--------------------------------------------------------------------------------
 1 | package common
 2 | 
 3 | import "github.com/codedellemc/scaleio-framework/scaleio-scheduler/types"
 4 | 
 5 | const (
 6 | 	//PollStatusInSeconds the amount of time to wait before updating state
 7 | 	PollStatusInSeconds = 60
 8 | 
 9 | 	//WaitForVolumeState the amount of time to wait for volume state changes
10 | 	WaitForVolumeState = 1
11 | )
12 | 
13 | //RetrieveState is a call back to retrieve an update of the state
14 | type RetrieveState func() (*types.ScaleIOFramework, error)
15 | 
16 | //SyncRunState a function to waiting on a specific state
17 | func SyncRunState(state *types.ScaleIOFramework, runState int, allNodes bool) bool {
18 | 	for _, node := range state.ScaleIO.Nodes {
19 | 		switch node.Persona {
20 | 		case types.PersonaMdmPrimary:
21 | 			if node.State < runState {
22 | 				return false
23 | 			}
24 | 		case types.PersonaMdmSecondary:
25 | 			if node.State < runState {
26 | 				return false
27 | 			}
28 | 		case types.PersonaTb:
29 | 			if node.State < runState {
30 | 				return false
31 | 			}
32 | 		case types.PersonaNode:
33 | 			if allNodes && node.State < runState {
34 | 				return false
35 | 			}
36 | 		}
37 | 	}
38 | 
39 | 	return true
40 | }
41 | 


--------------------------------------------------------------------------------
/scaleio-scheduler/scheduler/eventhandler.go:
--------------------------------------------------------------------------------
 1 | package scheduler
 2 | 
 3 | import (
 4 | 	log "github.com/Sirupsen/logrus"
 5 | 
 6 | 	sched "github.com/codedellemc/scaleio-framework/scaleio-scheduler/mesos/sched"
 7 | 	common "github.com/codedellemc/scaleio-framework/scaleio-scheduler/scheduler/common"
 8 | )
 9 | 
10 | func (s *ScaleIOScheduler) subscribed(event *sched.Event) {
11 | 	sub := event.GetSubscribed()
12 | 	s.Framework.Id = sub.FrameworkId
13 | 	log.Infoln("[EVENT] Received SUBSCRIBED. FrameworkID:", sub.FrameworkId.GetValue())
14 | }
15 | 
16 | func (s *ScaleIOScheduler) offers(event *sched.Event) {
17 | 	offers := event.GetOffers().GetOffers()
18 | 	log.Infoln("[EVENT] Received", len(offers), "OFFERS")
19 | 
20 | 	err := s.performNodeSelection(offers)
21 | 	if err != nil {
22 | 		log.Errorln("Failed to determine ScaleIO configuration:", err)
23 | 	}
24 | 
25 | 	//setup executors
26 | 	for _, offer := range offers {
27 | 		log.Debugln("Offer:", offer)
28 | 
29 | 		// account for executor resources if there's an executor already running on the slave
30 | 		if doesExecutorExistOnHost(offer) {
31 | 			log.Debugln("Skipping agent as it already has an executor on it. Decline offer.")
32 | 			message := generateDeclineCall(s.Config, offer)
33 | 			s.send(message)
34 | 			continue
35 | 		}
36 | 
37 | 		//find node based on state
38 | 		node := common.FindScaleIONodeByHostname(s.Server.State.ScaleIO.Nodes, offer.GetHostname())
39 | 		if node == nil {
40 | 			log.Errorln("Unable to find node by Hostname:", offer.GetHostname())
41 | 			message := generateDeclineCall(s.Config, offer)
42 | 			s.send(message)
43 | 			continue
44 | 		}
45 | 
46 | 		//generate accept call to launch executor
47 | 		message := generateAcceptCall(s.Config, offer, node)
48 | 		s.send(message)
49 | 	}
50 | }
51 | 
52 | func (s *ScaleIOScheduler) rescind(event *sched.Event) {
53 | 	rescind := event.GetRescind()
54 | 	log.Infoln("[EVENT] Received RESCIND:", rescind.String())
55 | }
56 | 
57 | func (s *ScaleIOScheduler) update(event *sched.Event) {
58 | 	update := event.GetUpdate().GetStatus()
59 | 	log.Infoln("[EVENT] Received STATUS:", update.String())
60 | 
61 | 	ackRequired := len(update.Uuid) > 0
62 | 	if ackRequired {
63 | 		message := generateAcknowledgeCall(s.Framework, update)
64 | 		s.send(message)
65 | 	} else {
66 | 		log.Infoln("Not sending ACK, update is not from slave")
67 | 	}
68 | }
69 | 
70 | func (s *ScaleIOScheduler) message(event *sched.Event) {
71 | 	message := event.GetMessage()
72 | 	log.Infoln("[EVENT] Received MESSAGE:", message.String())
73 | }
74 | 
75 | func (s *ScaleIOScheduler) failure(event *sched.Event) {
76 | 	log.Infoln("[EVENT] Received FAILURE")
77 | 	fail := event.GetFailure()
78 | 	if fail.ExecutorId != nil {
79 | 		log.Infoln(
80 | 			"Executor", fail.ExecutorId.GetValue(), "terminated",
81 | 			"with status", fail.GetStatus(),
82 | 			"on agent", fail.GetAgentId().GetValue(),
83 | 		)
84 | 	} else {
85 | 		if fail.GetAgentId() != nil {
86 | 			log.Infoln("Agent", fail.GetAgentId().GetValue(), "failed")
87 | 		}
88 | 	}
89 | }
90 | 
91 | func (s *ScaleIOScheduler) error(event *sched.Event) {
92 | 	err := event.GetError().GetMessage()
93 | 	log.Infoln("[EVENT] Received ERROR:", err)
94 | }
95 | 
96 | func (s *ScaleIOScheduler) heartbeat(event *sched.Event) {
97 | 	log.Infoln("[EVENT] Received HEARTBEAT")
98 | }
99 | 


--------------------------------------------------------------------------------
/scaleio-scheduler/scheduler/mesos.go:
--------------------------------------------------------------------------------
  1 | package scheduler
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 
  6 | 	log "github.com/Sirupsen/logrus"
  7 | 	"github.com/gogo/protobuf/proto"
  8 | 
  9 | 	"github.com/codedellemc/scaleio-framework/scaleio-scheduler/config"
 10 | 	sched "github.com/codedellemc/scaleio-framework/scaleio-scheduler/mesos/sched"
 11 | 	mesos "github.com/codedellemc/scaleio-framework/scaleio-scheduler/mesos/v1"
 12 | 	types "github.com/codedellemc/scaleio-framework/scaleio-scheduler/types"
 13 | )
 14 | 
 15 | func prepareExecutorInfo(cfg *config.Config, executorID string) *mesos.ExecutorInfo {
 16 | 	schedulerURI := fmt.Sprintf("http://%s:%d", cfg.RestAddress, cfg.RestPort)
 17 | 	log.Infoln("Scheduler URI:", schedulerURI)
 18 | 	uri := fmt.Sprintf("%s/scaleio-executor", schedulerURI)
 19 | 	log.Infoln("Executor URI:", uri)
 20 | 
 21 | 	executorUris := []*mesos.CommandInfo_URI{}
 22 | 	executorUris = append(executorUris, &mesos.CommandInfo_URI{Value: &uri, Executable: proto.Bool(true)})
 23 | 	executorCommand := fmt.Sprintf(
 24 | 		"chmod u+x scaleio-executor && ./scaleio-executor -loglevel=%s -rest.uri=%s",
 25 | 		cfg.LogLevel, schedulerURI)
 26 | 
 27 | 	// Create mesos scheduler driver.
 28 | 	return &mesos.ExecutorInfo{
 29 | 		Name:       proto.String("scaleio-executor"),
 30 | 		ExecutorId: &mesos.ExecutorID{Value: proto.String(executorID)},
 31 | 		Command: &mesos.CommandInfo{
 32 | 			Value: proto.String(executorCommand), //command to run on agent
 33 | 			Uris:  executorUris,                  //URI to download
 34 | 		},
 35 | 	}
 36 | }
 37 | 
 38 | func prepareFrameworkInfo(cfg *config.Config) *mesos.FrameworkInfo {
 39 | 	// the framework
 40 | 	fwinfo := &mesos.FrameworkInfo{
 41 | 		User:     proto.String(cfg.User),
 42 | 		Name:     proto.String("ScaleIO Framework"),
 43 | 		Hostname: proto.String(cfg.Hostname),
 44 | 	}
 45 | 
 46 | 	return fwinfo
 47 | }
 48 | 
 49 | func generateAcknowledgeCall(ID *mesos.FrameworkInfo, update *mesos.TaskStatus) *sched.Call {
 50 | 	message := &sched.Call{
 51 | 		FrameworkId: ID.GetId(),
 52 | 		Type:        sched.Call_ACKNOWLEDGE.Enum(),
 53 | 		Acknowledge: &sched.Call_Acknowledge{
 54 | 			AgentId: update.GetAgentId(),
 55 | 			TaskId:  update.GetTaskId(),
 56 | 			Uuid:    update.GetUuid(),
 57 | 		},
 58 | 	}
 59 | 
 60 | 	return message
 61 | }
 62 | 
 63 | func generateAcceptCall(cfg *config.Config, offer *mesos.Offer, node *types.ScaleIONode) *sched.Call {
 64 | 	//offer ids
 65 | 	var offerIDs []*mesos.OfferID
 66 | 
 67 | 	myID := &mesos.OfferID{
 68 | 		Value: offer.GetId().Value,
 69 | 	}
 70 | 	offerIDs = append(offerIDs, myID)
 71 | 
 72 | 	log.Infoln("OfferID:")
 73 | 	log.Infoln(myID.String())
 74 | 
 75 | 	//create task
 76 | 	var tasks []*mesos.TaskInfo
 77 | 
 78 | 	taskID := &mesos.TaskID{
 79 | 		Value: proto.String(node.TaskID),
 80 | 	}
 81 | 
 82 | 	log.Infoln("TaskID:")
 83 | 	log.Infoln(taskID.String())
 84 | 
 85 | 	cpu := cfg.ExecutorNonCPU
 86 | 	mem := cfg.ExecutorNonMemory
 87 | 	if IsNodeAnMDMNode(node) {
 88 | 		cpu = cfg.ExecutorMdmCPU
 89 | 		mem = cfg.ExecutorMdmMemory
 90 | 	}
 91 | 
 92 | 	task := &mesos.TaskInfo{
 93 | 		Name:     proto.String("task-" + node.TaskID),
 94 | 		TaskId:   taskID,
 95 | 		AgentId:  offer.GetAgentId(),
 96 | 		Executor: prepareExecutorInfo(cfg, node.ExecutorID),
 97 | 		Resources: []*mesos.Resource{
 98 | 			&mesos.Resource{
 99 | 				Name:   proto.String("cpus"),
100 | 				Type:   mesos.Value_SCALAR.Enum(),
101 | 				Scalar: &mesos.Value_Scalar{Value: proto.Float64(cpu)},
102 | 			},
103 | 			&mesos.Resource{
104 | 				Name:   proto.String("mem"),
105 | 				Type:   mesos.Value_SCALAR.Enum(),
106 | 				Scalar: &mesos.Value_Scalar{Value: proto.Float64(mem)},
107 | 			},
108 | 		},
109 | 	}
110 | 
111 | 	tasks = append(tasks, task)
112 | 
113 | 	log.Infoln("Task:")
114 | 	log.Infoln(task.String())
115 | 
116 | 	//create operations
117 | 	var operations []*mesos.Offer_Operation
118 | 
119 | 	operation := &mesos.Offer_Operation{
120 | 		Type: mesos.Offer_Operation_LAUNCH.Enum(),
121 | 		Launch: &mesos.Offer_Operation_Launch{
122 | 			TaskInfos: tasks,
123 | 		},
124 | 	}
125 | 
126 | 	operations = append(operations, operation)
127 | 
128 | 	log.Infoln("Operation:")
129 | 	log.Infoln(operation.String())
130 | 
131 | 	//launch the task
132 | 	message := &sched.Call{
133 | 		FrameworkId: offer.GetFrameworkId(),
134 | 		Type:        sched.Call_ACCEPT.Enum(),
135 | 		Accept: &sched.Call_Accept{
136 | 			OfferIds:   offerIDs,
137 | 			Operations: operations,
138 | 			Filters:    &mesos.Filters{RefuseSeconds: proto.Float64(30)},
139 | 		},
140 | 	}
141 | 
142 | 	log.Infoln("Call:")
143 | 	log.Infoln(message.String())
144 | 
145 | 	return message
146 | }
147 | 
148 | func generateDeclineCall(cfg *config.Config, offer *mesos.Offer) *sched.Call {
149 | 	//offer ids
150 | 	var offerIDs []*mesos.OfferID
151 | 
152 | 	myID := &mesos.OfferID{
153 | 		Value: offer.GetId().Value,
154 | 	}
155 | 	offerIDs = append(offerIDs, myID)
156 | 
157 | 	log.Infoln("OfferID:")
158 | 	log.Infoln(myID.String())
159 | 
160 | 	//decline the offer
161 | 	message := &sched.Call{
162 | 		FrameworkId: offer.GetFrameworkId(),
163 | 		Type:        sched.Call_DECLINE.Enum(),
164 | 		Decline: &sched.Call_Decline{
165 | 			OfferIds: offerIDs,
166 | 			Filters:  &mesos.Filters{RefuseSeconds: proto.Float64(30)},
167 | 		},
168 | 	}
169 | 
170 | 	log.Infoln("Call:")
171 | 	log.Infoln(message.String())
172 | 
173 | 	return message
174 | }
175 | 
176 | func filterResources(resources []*mesos.Resource, filter func(*mesos.Resource) bool) (result []*mesos.Resource) {
177 | 	for _, resource := range resources {
178 | 		if filter(resource) {
179 | 			result = append(result, resource)
180 | 		}
181 | 	}
182 | 	return result
183 | }
184 | 
185 | func doesExecutorExistOnHost(offer *mesos.Offer) bool {
186 | 	// account for executor resources if there's an executor already running on the slave
187 | 	if len(offer.ExecutorIds) != 0 {
188 | 		log.Infoln("scaleio-executor already exists on host", offer.GetId().GetValue(),
189 | 			",", offer.GetHostname(), ",", offer.GetAgentId())
190 | 	}
191 | 
192 | 	return len(offer.ExecutorIds) != 0
193 | }
194 | 


--------------------------------------------------------------------------------
/scaleio-scheduler/scheduler/scaleio.go:
--------------------------------------------------------------------------------
  1 | package scheduler
  2 | 
  3 | import (
  4 | 	"strings"
  5 | 
  6 | 	log "github.com/Sirupsen/logrus"
  7 | 
  8 | 	mesos "github.com/codedellemc/scaleio-framework/scaleio-scheduler/mesos/v1"
  9 | 	common "github.com/codedellemc/scaleio-framework/scaleio-scheduler/scheduler/common"
 10 | 	kvstore "github.com/codedellemc/scaleio-framework/scaleio-scheduler/scheduler/kvstore"
 11 | 	types "github.com/codedellemc/scaleio-framework/scaleio-scheduler/types"
 12 | )
 13 | 
 14 | //IsNodeAnMDMNode returns true is node is an MDM node
 15 | func IsNodeAnMDMNode(node *types.ScaleIONode) bool {
 16 | 	isMDM := node.Persona == types.PersonaMdmPrimary ||
 17 | 		node.Persona == types.PersonaMdmSecondary ||
 18 | 		node.Persona == types.PersonaTb
 19 | 	if isMDM {
 20 | 		log.Debugln("Node is an MDM Node")
 21 | 	} else {
 22 | 		log.Debugln("Node is an Data Node")
 23 | 	}
 24 | 	return isMDM
 25 | }
 26 | 
 27 | func appendClientPrefix(key string) string {
 28 | 	if strings.Contains(key, "scaleio-sdc-") {
 29 | 		return key
 30 | 	}
 31 | 	return "scaleio-sdc-" + key
 32 | }
 33 | 
 34 | func appendServerPrefix(key string) string {
 35 | 	if strings.Contains(key, "scaleio-sds-") {
 36 | 		return key
 37 | 	}
 38 | 	return "scaleio-sds-" + key
 39 | }
 40 | 
 41 | func getAttributeByKey(attribs []*mesos.Attribute, key string) (string, error) {
 42 | 	for _, attrib := range attribs {
 43 | 		if attrib.GetName() == key {
 44 | 			return attrib.GetText().GetValue(), nil
 45 | 		}
 46 | 	}
 47 | 
 48 | 	return "", common.ErrAttributeNotFound
 49 | }
 50 | 
 51 | type fixprefix func(string) string
 52 | 
 53 | func prepareScaleIONode(store *kvstore.KvStore, offer *mesos.Offer) (*types.ScaleIONode, error) {
 54 | 	persona, state, err := store.GetNodeInfo(offer.GetHostname())
 55 | 	if err != nil {
 56 | 		log.Errorln("Unable to find Node metadata for", offer.GetHostname())
 57 | 		return nil, err
 58 | 	}
 59 | 
 60 | 	node := &types.ScaleIONode{
 61 | 		AgentID:     offer.GetAgentId().GetValue(),
 62 | 		TaskID:      "scaleio-" + offer.GetHostname(),
 63 | 		ExecutorID:  "executor-scaleio-" + offer.GetHostname(),
 64 | 		OfferID:     offer.GetId().GetValue(),
 65 | 		IPAddress:   offer.GetUrl().GetAddress().GetIp(),
 66 | 		Hostname:    offer.GetHostname(),
 67 | 		Persona:     persona,
 68 | 		State:       state,
 69 | 		LastContact: 0,
 70 | 		Imperative:  false,
 71 | 		Advertised:  false,
 72 | 	}
 73 | 
 74 | 	keys := []string{
 75 | 		"scaleio-sds-domains",
 76 | 		"scaleio-sdc-domains",
 77 | 	}
 78 | 	fixprefix := []fixprefix{
 79 | 		appendServerPrefix,
 80 | 		appendClientPrefix,
 81 | 	}
 82 | 
 83 | 	for i := 0; i < 2; i++ {
 84 | 		value, err := getAttributeByKey(offer.GetAttributes(), keys[i])
 85 | 		if err != nil {
 86 | 			log.Warnln("Attribute", keys[i], "not found")
 87 | 			continue
 88 | 		}
 89 | 
 90 | 		//this means this particular node was explicitly provisioned
 91 | 		node.Imperative = true
 92 | 
 93 | 		fsDomains := strings.Split(value, ",")
 94 | 		for _, fsDomain := range fsDomains {
 95 | 
 96 | 			if node.ProvidesDomains == nil {
 97 | 				node.ProvidesDomains = make(map[string]*types.ProtectionDomain)
 98 | 			}
 99 | 			if node.ProvidesDomains[fsDomain] == nil {
100 | 				node.ProvidesDomains[fsDomain] = &types.ProtectionDomain{
101 | 					Name:     fsDomain,
102 | 					KeyValue: make(map[string]string),
103 | 				}
104 | 			}
105 | 			nDomain := node.ProvidesDomains[fsDomain]
106 | 
107 | 			poolsStr, err := getAttributeByKey(offer.GetAttributes(), fixprefix[i](fsDomain))
108 | 			if err != nil {
109 | 				log.Warnln("Attribute", fixprefix[i](fsDomain), "not found")
110 | 				continue
111 | 			}
112 | 
113 | 			fsPools := strings.Split(poolsStr, ",")
114 | 			for _, fsPool := range fsPools {
115 | 
116 | 				if nDomain.Pools == nil {
117 | 					nDomain.Pools = make(map[string]*types.StoragePool)
118 | 				}
119 | 				if nDomain.Pools[fsPool] == nil {
120 | 					nDomain.Pools[fsPool] = &types.StoragePool{
121 | 						Name:     fsPool,
122 | 						KeyValue: make(map[string]string),
123 | 					}
124 | 				}
125 | 				nPool := nDomain.Pools[fsPool]
126 | 
127 | 				deviceStr, err := getAttributeByKey(offer.GetAttributes(), fixprefix[i](fsPool))
128 | 				if err != nil {
129 | 					log.Warnln("Attribute", fixprefix[i](fsPool), "not found")
130 | 					continue
131 | 				}
132 | 
133 | 				fsDevices := strings.Split(deviceStr, ",")
134 | 				for _, fsDevice := range fsDevices {
135 | 					if nPool.Devices == nil {
136 | 						nPool.Devices = make([]string, 0)
137 | 					}
138 | 					//TODO check for device
139 | 					nPool.Devices = append(nPool.Devices, fsDevice)
140 | 				}
141 | 			}
142 | 		}
143 | 	}
144 | 
145 | 	return node, nil
146 | }
147 | 
148 | func (s *ScaleIOScheduler) addScaleIONode(offer *mesos.Offer) error {
149 | 	node := common.FindScaleIONodeByHostname(s.Server.State.ScaleIO.Nodes, offer.GetHostname())
150 | 	if node != nil {
151 | 		return common.ErrNodeNotFound
152 | 	}
153 | 
154 | 	node, err := prepareScaleIONode(s.Store, offer)
155 | 	if err != nil {
156 | 		return err
157 | 	}
158 | 
159 | 	if node.Imperative {
160 | 		log.Infoln("At least one node declared by Imperative method.")
161 | 		s.Server.State.ScaleIO.AtLeastOneImperative = true
162 | 	}
163 | 
164 | 	s.Server.State.ScaleIO.Nodes = append(s.Server.State.ScaleIO.Nodes, node)
165 | 	return nil
166 | }
167 | 


--------------------------------------------------------------------------------
/scaleio-scheduler/scheduler/scheduler.go:
--------------------------------------------------------------------------------
  1 | package scheduler
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	"errors"
  6 | 	"fmt"
  7 | 	"io"
  8 | 	"net/http"
  9 | 	"time"
 10 | 
 11 | 	log "github.com/Sirupsen/logrus"
 12 | 	jsonpb "github.com/gogo/protobuf/jsonpb"
 13 | 	"github.com/gogo/protobuf/proto"
 14 | 
 15 | 	"github.com/codedellemc/scaleio-framework/scaleio-scheduler/client"
 16 | 	"github.com/codedellemc/scaleio-framework/scaleio-scheduler/config"
 17 | 	sched "github.com/codedellemc/scaleio-framework/scaleio-scheduler/mesos/sched"
 18 | 	mesos "github.com/codedellemc/scaleio-framework/scaleio-scheduler/mesos/v1"
 19 | 	kvstore "github.com/codedellemc/scaleio-framework/scaleio-scheduler/scheduler/kvstore"
 20 | 	"github.com/codedellemc/scaleio-framework/scaleio-scheduler/scheduler/server"
 21 | )
 22 | 
 23 | const (
 24 | 	subscribeRetryDelayInSec = 2
 25 | 	rootKey                  = "scaleio-framework"
 26 | )
 27 | 
 28 | //ScaleIOScheduler represents a Mesos scheduler
 29 | type ScaleIOScheduler struct {
 30 | 	Config *config.Config
 31 | 	Store  *kvstore.KvStore
 32 | 
 33 | 	Framework *mesos.FrameworkInfo
 34 | 
 35 | 	Server *server.RestServer
 36 | 	Client *client.Client
 37 | 
 38 | 	Events   chan *sched.Event
 39 | 	DoneChan chan struct{}
 40 | }
 41 | 
 42 | //NewScaleIOScheduler returns a pointer to new Scheduler
 43 | func NewScaleIOScheduler(cfg *config.Config) *ScaleIOScheduler {
 44 | 	myStore, err := kvstore.NewKvStore(cfg)
 45 | 	if err != nil {
 46 | 		log.Fatalln("NewKvStore Failed. Err:", err)
 47 | 		return nil
 48 | 	}
 49 | 
 50 | 	if cfg.DeleteKeyValues {
 51 | 		myStore.DeleteStore()
 52 | 		return nil
 53 | 	} else if cfg.DumpKeyValues {
 54 | 		myStore.DumpStore()
 55 | 		return nil
 56 | 	} else if len(cfg.StoreAddKey) > 0 {
 57 | 		err := myStore.UserKeyValue(cfg.StoreAddKey, cfg.StoreAddVal)
 58 | 		if err == nil {
 59 | 			log.Infoln("UserKeyValue Succeeded")
 60 | 		} else {
 61 | 			log.Errorln("UserKeyValue Failed. Err:", err)
 62 | 		}
 63 | 		return nil
 64 | 	} else if len(cfg.StoreDelKey) > 0 {
 65 | 		err := myStore.UserDeleteKey(cfg.StoreDelKey)
 66 | 		if err == nil {
 67 | 			log.Infoln("UserDeleteKey Succeeded")
 68 | 		} else {
 69 | 			log.Errorln("UserDeleteKey Failed. Err:", err)
 70 | 		}
 71 | 		return nil
 72 | 	}
 73 | 
 74 | 	return &ScaleIOScheduler{
 75 | 		Config:    cfg,
 76 | 		Store:     myStore,
 77 | 		Client:    client.New(cfg.MasterREST, "/api/v1/scheduler"),
 78 | 		Server:    server.NewRestServer(cfg, myStore),
 79 | 		Framework: prepareFrameworkInfo(cfg),
 80 | 		Events:    make(chan *sched.Event),
 81 | 		DoneChan:  make(chan struct{}),
 82 | 	}
 83 | }
 84 | 
 85 | //Start starts the scheduler and subscribes to event stream
 86 | // returns a channel to wait for completion.
 87 | func (s *ScaleIOScheduler) Start() <-chan struct{} {
 88 | 	if err := s.subscribe(); err != nil {
 89 | 		log.Errorln("Failed to subscribe:", err)
 90 | 	}
 91 | 	go s.handleEvents()
 92 | 	return s.DoneChan
 93 | }
 94 | 
 95 | //Stop the scheduler and all internal channels
 96 | func (s *ScaleIOScheduler) Stop() {
 97 | 	close(s.Events)
 98 | 	close(s.DoneChan)
 99 | }
100 | 
101 | func (s *ScaleIOScheduler) send(call *sched.Call) (*http.Response, error) {
102 | 	marshaler := jsonpb.Marshaler{
103 | 		EnumsAsInts:  true,
104 | 		EmitDefaults: false,
105 | 		Indent:       "  ",
106 | 		OrigName:     false,
107 | 	}
108 | 	strJSON, errJSON := marshaler.MarshalToString(call)
109 | 	if errJSON == nil {
110 | 		log.Debugln("JSON:\n", strJSON)
111 | 	} else {
112 | 		log.Debugln("Unable to marshal to JSON:", errJSON)
113 | 	}
114 | 
115 | 	payload, err := proto.Marshal(call)
116 | 	if err != nil {
117 | 		log.Errorln("Failed to Marshal Protobuf:", err)
118 | 		return nil, err
119 | 	}
120 | 
121 | 	resp, err := s.Client.Send(payload)
122 | 	if err != nil {
123 | 		return nil, err
124 | 	}
125 | 	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusAccepted {
126 | 		msg := fmt.Sprint("StatusCode is not equal to StatusOK:", resp.StatusCode)
127 | 		log.Errorln(msg)
128 | 		return nil, errors.New(msg)
129 | 	}
130 | 
131 | 	log.Infoln("StatusCode: StatusOK")
132 | 	return resp, nil
133 | }
134 | 
135 | // Subscribe subscribes the scheduler to the Mesos cluster.
136 | // It keeps the http connection opens with the Master to stream
137 | // subsequent events.
138 | func (s *ScaleIOScheduler) subscribe() error {
139 | 	for {
140 | 		call := &sched.Call{
141 | 			Type: sched.Call_SUBSCRIBE.Enum(),
142 | 			Subscribe: &sched.Call_Subscribe{
143 | 				FrameworkInfo: s.Framework,
144 | 			},
145 | 		}
146 | 
147 | 		resp, err := s.send(call)
148 | 		if err != nil {
149 | 			log.Warnln("subscribe error:", err)
150 | 		} else if resp != nil {
151 | 			go s.qEvents(resp)
152 | 			break
153 | 		}
154 | 
155 | 		time.Sleep(time.Duration(subscribeRetryDelayInSec) * time.Second)
156 | 	}
157 | 	return nil
158 | }
159 | 
160 | func (s *ScaleIOScheduler) qEvents(resp *http.Response) {
161 | 	log.Debugln("qEvents ENTER")
162 | 	defer func() {
163 | 		resp.Body.Close()
164 | 		close(s.Events)
165 | 	}()
166 | 
167 | 	dec := json.NewDecoder(resp.Body)
168 | 	for {
169 | 		event := new(sched.Event)
170 | 		if event == nil {
171 | 			log.Errorln("Event is nil")
172 | 		}
173 | 		log.Debugln("Waiting for Event")
174 | 		err := dec.Decode(event)
175 | 		log.Debugln("Received for Event")
176 | 		if err != nil {
177 | 			if err == io.EOF {
178 | 				log.Debugln("err == io.EOF")
179 | 				log.Debugln("qEvents LEAVE")
180 | 				return
181 | 			}
182 | 
183 | 			//TODO fix this at some point. This is due to the RecordIO Format
184 | 			// RecordIO = <Message LENGTH>\n<Message of Size=LENGTH>
185 | 			log.Warnln("Unable to decode event. Skip event. Err:", err)
186 | 			continue
187 | 		}
188 | 		log.Debugln("Adding Event:", event.String())
189 | 		s.Events <- event
190 | 	}
191 | }
192 | 
193 | func (s *ScaleIOScheduler) handleEvents() {
194 | 	defer close(s.DoneChan)
195 | 	for event := range s.Events {
196 | 		switch event.GetType() {
197 | 
198 | 		case sched.Event_SUBSCRIBED:
199 | 			s.subscribed(event)
200 | 
201 | 		case sched.Event_OFFERS:
202 | 			s.offers(event)
203 | 
204 | 		case sched.Event_RESCIND:
205 | 			s.rescind(event)
206 | 
207 | 		case sched.Event_UPDATE:
208 | 			s.update(event)
209 | 
210 | 		case sched.Event_MESSAGE:
211 | 			s.message(event)
212 | 
213 | 		case sched.Event_FAILURE:
214 | 			s.failure(event)
215 | 
216 | 		case sched.Event_ERROR:
217 | 			s.error(event)
218 | 
219 | 		case sched.Event_HEARTBEAT:
220 | 			s.heartbeat(event)
221 | 		}
222 | 	}
223 | }
224 | 


--------------------------------------------------------------------------------
/scaleio-scheduler/scheduler/selection.go:
--------------------------------------------------------------------------------
  1 | package scheduler
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 
  6 | 	log "github.com/Sirupsen/logrus"
  7 | 
  8 | 	mesos "github.com/codedellemc/scaleio-framework/scaleio-scheduler/mesos/v1"
  9 | 	common "github.com/codedellemc/scaleio-framework/scaleio-scheduler/scheduler/common"
 10 | 	types "github.com/codedellemc/scaleio-framework/scaleio-scheduler/types"
 11 | )
 12 | 
 13 | /*
 14 | Metadata structure on disk for the Mesos Agent:
 15 | 
 16 | /etc/mesos-slave/attributes/<attribute name>
 17 |     protection domain
 18 |     storage pool - 1 to many devices
 19 | 
 20 | scaleio-s-domains = domain1,domain2
 21 | scaleio-s-domain1 = pool1,pool2
 22 | scaleio-s-domain2 = pool3
 23 | scaleio-s-pool1 = /dev/vxdf,/dev/vxdg
 24 | 
 25 | scaleio-c-domains = domain1,domain2
 26 | scaleio-c-domain1 = pool1
 27 | scaleio-c-domain2 = pool3
 28 | 
 29 | 
 30 | Metadata structure in the KeyValue Store:
 31 | 
 32 | scaleio-framework/<framework role>
 33 | 	version = 1
 34 | 	/configuration
 35 | 		configured = true
 36 | 		primary = "10.0.0.10"
 37 | 		secondary = "10.0.0.11"
 38 | 		tiebreaker = "10.0.0.12"
 39 | 	/nodes
 40 | 		/10.0.0.10
 41 | 			persona = 1
 42 | 			state = 2, 3, etc
 43 | 			/domains
 44 | 				sdss = 10.0.0.10_sds1,10.0.0.10_sds2
 45 | 				domains = domain1,domain2
 46 | 				/domain1
 47 | 					pools = pool1,pool2
 48 | 					pool1 = /dev/xvdf,/dev/xvdg
 49 | 					pool2 = /dev/xvdh
 50 | 				/domain2
 51 | 					pools = pool3
 52 | 					pool3 = /dev/xvdi
 53 | 		/10.0.0.11
 54 | 			persona = 2
 55 | 			state = 2, 3, etc
 56 | 			/domains
 57 | 				...
 58 | 		/10.0.0.12
 59 | 			persona = 3
 60 | 			state = 2, 3, etc
 61 | 			/domains
 62 | 				...
 63 | 		/10.0.0.13
 64 | 			persona = 4
 65 | 			state = 2, 3, etc
 66 | 			/domains
 67 | 				...
 68 | */
 69 | 
 70 | var (
 71 | 	//ErrMdmSelectionFailed Unable to select an MDM node from available Agents
 72 | 	ErrMdmSelectionFailed = errors.New("Unable to select an MDM node from available Agents")
 73 | )
 74 | 
 75 | func getManuallyConfigNode(offers []*mesos.Offer, persona int) *mesos.Offer {
 76 | 	for _, offer := range offers {
 77 | 		attribs := offer.GetAttributes()
 78 | 		for _, attrib := range attribs {
 79 | 			if attrib.GetName() == "scaleio-persona" &&
 80 | 				attrib.GetText().GetValue() == common.PersonaIDToString(persona) {
 81 | 				return offer
 82 | 			}
 83 | 		}
 84 | 	}
 85 | 	return nil
 86 | }
 87 | 
 88 | func (s *ScaleIOScheduler) obtainBestOfferForMdm(offers []*mesos.Offer) *mesos.Offer {
 89 | 	var highestCPU float64
 90 | 	var highestMem float64
 91 | 	var higherOffer *mesos.Offer
 92 | 
 93 | 	for _, offer := range offers {
 94 | 		//has the node already been allocated?
 95 | 		_, _, err := s.Store.GetNodeInfo(offer.GetHostname())
 96 | 		if err == nil {
 97 | 			continue
 98 | 		}
 99 | 
100 | 		cpuResources := filterResources(offer.Resources, func(res *mesos.Resource) bool {
101 | 			return res.GetName() == "cpus"
102 | 		})
103 | 		cpus := 0.0
104 | 		for _, res := range cpuResources {
105 | 			cpus += res.GetScalar().GetValue()
106 | 		}
107 | 
108 | 		memResources := filterResources(offer.Resources, func(res *mesos.Resource) bool {
109 | 			return res.GetName() == "mem"
110 | 		})
111 | 		mems := 0.0
112 | 		for _, res := range memResources {
113 | 			mems += res.GetScalar().GetValue()
114 | 		}
115 | 
116 | 		if s.Config.ExecutorMdmCPU >= (cpus*s.Config.ExecutorCPUFactor) ||
117 | 			s.Config.ExecutorMdmMemory >= (mems*s.Config.ExecutorMemoryFactor) {
118 | 			continue
119 | 		}
120 | 
121 | 		if cpus > (highestCPU*.75) && mems > (highestMem*1.25) {
122 | 			higherOffer = offer
123 | 			highestCPU = cpus
124 | 			highestMem = mems
125 | 		} else if cpus > highestCPU {
126 | 			higherOffer = offer
127 | 			highestCPU = cpus
128 | 			highestMem = mems
129 | 		}
130 | 	}
131 | 
132 | 	return higherOffer
133 | }
134 | 
135 | func (s *ScaleIOScheduler) selectAnMdmNode(offers []*mesos.Offer, nodeID string, mdmType int) error {
136 | 	node := common.FindScaleIONodeByHostname(s.Server.State.ScaleIO.Nodes, nodeID)
137 | 	if node != nil {
138 | 		log.Debugln(common.PersonaIDToString(mdmType), " MDM node exists already")
139 | 	} else if _, _, err := s.Store.GetNodeInfo(nodeID); err == nil {
140 | 		log.Debugln(common.PersonaIDToString(mdmType), " MDM metadata exists, but not in state object")
141 | 
142 | 		for _, offer := range offers {
143 | 			if offer.GetHostname() == nodeID {
144 | 				log.Debugln("Found offer based on nodeID:", nodeID)
145 | 				s.addScaleIONode(offer)
146 | 				break
147 | 			}
148 | 		}
149 | 	} else if offer := getManuallyConfigNode(offers, mdmType); offer != nil {
150 | 		log.Debugln(common.PersonaIDToString(mdmType), " MDM has been manually selected")
151 | 
152 | 		err := s.Store.SetNodeInfo(offer.GetHostname(), mdmType, types.StateUnknown)
153 | 		if err != nil {
154 | 			log.Debugln("Failed to set ", common.PersonaIDToString(mdmType), " MDM metadata:", err)
155 | 			return err
156 | 		}
157 | 		s.addScaleIONode(offer)
158 | 	} else {
159 | 		log.Debugln(common.PersonaIDToString(mdmType), "MDM needs to be automatically selected")
160 | 		offer := s.obtainBestOfferForMdm(offers)
161 | 		if offer == nil {
162 | 			log.Errorln("Unable to find an acceptable node to run the",
163 | 				common.PersonaIDToString(mdmType), "MDM node")
164 | 			return ErrMdmSelectionFailed
165 | 		}
166 | 
167 | 		err := s.Store.SetNodeInfo(offer.GetHostname(), mdmType, types.StateUnknown)
168 | 		if err != nil {
169 | 			log.Debugln("Failed to set ", common.PersonaIDToString(mdmType), " MDM metadata:", err)
170 | 			return err
171 | 		}
172 | 		s.addScaleIONode(offer)
173 | 	}
174 | 
175 | 	return nil
176 | }
177 | 
178 | func (s *ScaleIOScheduler) selectDataNode(offer *mesos.Offer) error {
179 | 	_, _, err := s.Store.GetNodeInfo(offer.GetHostname())
180 | 	if err != nil {
181 | 		err = s.Store.SetNodeInfo(offer.GetHostname(), types.PersonaNode, types.StateUnknown)
182 | 		if err != nil {
183 | 			log.Debugln("Failed to set data node metadata:", err)
184 | 			return err
185 | 		}
186 | 	}
187 | 	s.addScaleIONode(offer)
188 | 
189 | 	return nil
190 | }
191 | 
192 | func (s *ScaleIOScheduler) performNodeSelection(offers []*mesos.Offer) error {
193 | 	log.Debugln("performNodeSelection ENTER")
194 | 
195 | 	if s.Config.PrimaryMdmAddress == "" &&
196 | 		s.Config.SecondaryMdmAddress == "" &&
197 | 		s.Config.TieBreakerMdmAddress == "" {
198 | 		pri, sec, tb := s.Store.GetMdmNodes()
199 | 		if len(pri) == 0 {
200 | 			log.Debugln("The Primary MDM node has not been selected")
201 | 		} else {
202 | 			log.Debugln("The Primary MDM node has been selected:", pri)
203 | 		}
204 | 		err := s.selectAnMdmNode(offers, pri, types.PersonaMdmPrimary)
205 | 		if err != nil {
206 | 			log.Errorln("Failed to select a Primary MDM node:", err)
207 | 			log.Debugln("performNodeSelection LEAVE")
208 | 			return err
209 | 		}
210 | 
211 | 		if len(sec) == 0 {
212 | 			log.Debugln("The Secondary MDM node has not been selected")
213 | 		} else {
214 | 			log.Debugln("The Secondary MDM node has been selected:", sec)
215 | 		}
216 | 		err = s.selectAnMdmNode(offers, sec, types.PersonaMdmSecondary)
217 | 		if err != nil {
218 | 			log.Errorln("Failed to select a Secondary MDM node:", err)
219 | 			log.Debugln("performNodeSelection LEAVE")
220 | 			return err
221 | 		}
222 | 
223 | 		if len(tb) == 0 {
224 | 			log.Debugln("The Tiebreaker MDM node has not been selected")
225 | 		} else {
226 | 			log.Debugln("The Tiebreaker MDM node has been selected:", tb)
227 | 		}
228 | 		err = s.selectAnMdmNode(offers, tb, types.PersonaTb)
229 | 		if err != nil {
230 | 			log.Errorln("Failed to select a TieBreaker MDM node:", err)
231 | 			log.Debugln("performNodeSelection LEAVE")
232 | 			return err
233 | 		}
234 | 	}
235 | 
236 | 	for _, offer := range offers {
237 | 		if common.FindScaleIONodeByHostname(s.Server.State.ScaleIO.Nodes, offer.GetHostname()) != nil {
238 | 			log.Debugln("Node", offer.GetHostname(), "already has a persona")
239 | 			continue
240 | 		}
241 | 
242 | 		log.Debugln("Node", offer.GetHostname(), "persona being set to DataNode")
243 | 		err := s.selectDataNode(offer)
244 | 		if err != nil {
245 | 			log.Errorln("Failed to select data node:", err)
246 | 			log.Debugln("performNodeSelection LEAVE")
247 | 			return err
248 | 		}
249 | 	}
250 | 
251 | 	log.Debugln("performNodeSelection Succeeded")
252 | 	log.Debugln("performNodeSelection LEAVE")
253 | 	return nil
254 | }
255 | 


--------------------------------------------------------------------------------
/scaleio-scheduler/scheduler/server/executor.go:
--------------------------------------------------------------------------------
 1 | package server
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"os"
 6 | 
 7 | 	log "github.com/Sirupsen/logrus"
 8 | 
 9 | 	xplatform "github.com/dvonthenen/goxplatform"
10 | )
11 | 
12 | func downloadExecutor(w http.ResponseWriter, r *http.Request, server *RestServer) {
13 | 	path := server.Config.AltExecutorPath
14 | 	if len(path) == 0 {
15 | 		log.Debugln("AltExecutorPath = \"\" BEGIN")
16 | 		pathTmp, err := xplatform.GetInstance().Fs.GetFullPath()
17 | 		if err != nil {
18 | 			http.Error(w, "Unable to determine executor location", http.StatusNotFound)
19 | 			return
20 | 		}
21 | 		path = xplatform.GetInstance().Fs.AppendSlash(pathTmp) + "scaleio-executor"
22 | 		log.Debugln("Path:", path)
23 | 		log.Debugln("AltExecutorPath = \"\" END")
24 | 	}
25 | 	log.Infoln("Path:", path)
26 | 	_, err := os.Stat(path)
27 | 	if err != nil {
28 | 		http.Error(w, "File does not exist", http.StatusNotFound)
29 | 		log.Errorln("Executor does not exist:", path)
30 | 	}
31 | 	log.Debugln("Path:", path)
32 | 	http.ServeFile(w, r, path)
33 | }
34 | 


--------------------------------------------------------------------------------
/scaleio-scheduler/scheduler/server/node.go:
--------------------------------------------------------------------------------
  1 | package server
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	"io"
  6 | 	"io/ioutil"
  7 | 	"net/http"
  8 | 	"time"
  9 | 
 10 | 	log "github.com/Sirupsen/logrus"
 11 | 
 12 | 	"github.com/codedellemc/scaleio-framework/scaleio-scheduler/scheduler/common"
 13 | 	types "github.com/codedellemc/scaleio-framework/scaleio-scheduler/types"
 14 | )
 15 | 
 16 | func setNodeState(w http.ResponseWriter, r *http.Request, server *RestServer) {
 17 | 	body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
 18 | 	if err != nil {
 19 | 		http.Error(w, "Unable to read the HTTP Body stream", http.StatusBadRequest)
 20 | 		return
 21 | 	}
 22 | 	if err := r.Body.Close(); err != nil {
 23 | 		log.Warnln("Unable to close the HTTP Body stream:", err)
 24 | 	}
 25 | 
 26 | 	state := &types.UpdateNode{
 27 | 		Acknowledged: false,
 28 | 		ExecutorID:   "",
 29 | 		State:        types.StateUnknown,
 30 | 		KeyValue:     make(map[string]string),
 31 | 	}
 32 | 	if err := json.Unmarshal(body, &state); err != nil {
 33 | 		http.Error(w, "Unable to marshall the response", http.StatusBadRequest)
 34 | 		return
 35 | 	}
 36 | 
 37 | 	node := common.FindScaleIONodeByExecutorID(server.State.ScaleIO.Nodes, state.ExecutorID)
 38 | 	if node == nil {
 39 | 		http.Error(w, "Unable to find the Executor", http.StatusBadRequest)
 40 | 		return
 41 | 	}
 42 | 
 43 | 	server.Lock()
 44 | 	//set state on object...
 45 | 	node.State = state.State
 46 | 	node.LastContact = time.Now().Unix()
 47 | 
 48 | 	//save state in metadata...
 49 | 	err = server.Store.SetNodeInfo(node.Hostname, node.Persona, node.State)
 50 | 	server.Unlock()
 51 | 
 52 | 	if err != nil {
 53 | 		http.Error(w, "SetNodeInfo Err: "+err.Error(), http.StatusBadRequest)
 54 | 		return
 55 | 	}
 56 | 
 57 | 	//acknowledged the state change
 58 | 	state.Acknowledged = true
 59 | 
 60 | 	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
 61 | 	w.WriteHeader(http.StatusOK)
 62 | 	if err := json.NewEncoder(w).Encode(state); err != nil {
 63 | 		http.Error(w, "Unable to marshall the response", http.StatusBadRequest)
 64 | 	}
 65 | }
 66 | 
 67 | func setNodeDevices(w http.ResponseWriter, r *http.Request, server *RestServer) {
 68 | 	log.Debugln("setNodeDevices ENTER")
 69 | 
 70 | 	body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
 71 | 	if err != nil {
 72 | 		http.Error(w, "Unable to read the HTTP Body stream", http.StatusBadRequest)
 73 | 		return
 74 | 	}
 75 | 	if err := r.Body.Close(); err != nil {
 76 | 		log.Warnln("Unable to close the HTTP Body stream:", err)
 77 | 	}
 78 | 
 79 | 	state := &types.UpdateDevices{
 80 | 		Acknowledged: false,
 81 | 		ExecutorID:   "",
 82 | 		Devices:      make([]string, 0),
 83 | 		KeyValue:     make(map[string]string),
 84 | 	}
 85 | 	if err := json.Unmarshal(body, &state); err != nil {
 86 | 		http.Error(w, "Unable to marshall the response", http.StatusBadRequest)
 87 | 		return
 88 | 	}
 89 | 
 90 | 	node := common.FindScaleIONodeByExecutorID(server.State.ScaleIO.Nodes, state.ExecutorID)
 91 | 	if node == nil {
 92 | 		http.Error(w, "Unable to find the Executor", http.StatusBadRequest)
 93 | 		return
 94 | 	}
 95 | 
 96 | 	server.Lock()
 97 | 	//set last contact time on object...
 98 | 	node.LastContact = time.Now().Unix()
 99 | 
100 | 	//Set advertised!
101 | 	node.Advertised = true
102 | 
103 | 	for _, device := range state.Devices {
104 | 		log.Debugln("Device:", device)
105 | 		if node.ProvidesDomains == nil {
106 | 			node.ProvidesDomains = make(map[string]*types.ProtectionDomain)
107 | 		}
108 | 		if node.ProvidesDomains[server.Config.ProtectionDomain] == nil {
109 | 			log.Debugln("ProvidesDomains is nil")
110 | 			node.ProvidesDomains[server.Config.ProtectionDomain] = &types.ProtectionDomain{
111 | 				Name: server.Config.ProtectionDomain,
112 | 			}
113 | 		}
114 | 		pd := node.ProvidesDomains[server.Config.ProtectionDomain]
115 | 		if pd.Pools == nil {
116 | 			pd.Pools = make(map[string]*types.StoragePool)
117 | 		}
118 | 		if pd.Pools[server.Config.StoragePool] == nil {
119 | 			log.Debugln("Pools is nil")
120 | 			pd.Pools[server.Config.StoragePool] = &types.StoragePool{
121 | 				Name: server.Config.StoragePool,
122 | 			}
123 | 		}
124 | 		sp := pd.Pools[server.Config.StoragePool]
125 | 
126 | 		if sp.Devices == nil {
127 | 			log.Debugln("Devices is nil")
128 | 			sp.Devices = make([]string, 0)
129 | 		}
130 | 		log.Debugln("Add device")
131 | 		sp.Devices = append(sp.Devices, device)
132 | 	}
133 | 	server.Unlock()
134 | 
135 | 	//acknowledged the state change
136 | 	state.Acknowledged = true
137 | 
138 | 	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
139 | 	w.WriteHeader(http.StatusOK)
140 | 	if err := json.NewEncoder(w).Encode(state); err != nil {
141 | 		http.Error(w, "Unable to marshall the response", http.StatusBadRequest)
142 | 	}
143 | }
144 | 
145 | func setNodePing(w http.ResponseWriter, r *http.Request, server *RestServer) {
146 | 	body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
147 | 	if err != nil {
148 | 		http.Error(w, "Unable to read the HTTP Body stream", http.StatusBadRequest)
149 | 		return
150 | 	}
151 | 	if err := r.Body.Close(); err != nil {
152 | 		log.Warnln("Unable to close the HTTP Body stream:", err)
153 | 	}
154 | 
155 | 	state := &types.PingNode{
156 | 		Acknowledged: false,
157 | 		ExecutorID:   "",
158 | 		KeyValue:     make(map[string]string),
159 | 	}
160 | 	if err := json.Unmarshal(body, &state); err != nil {
161 | 		http.Error(w, "Unable to marshall the response", http.StatusBadRequest)
162 | 		return
163 | 	}
164 | 
165 | 	node := common.FindScaleIONodeByExecutorID(server.State.ScaleIO.Nodes, state.ExecutorID)
166 | 	if node == nil {
167 | 		http.Error(w, "Unable to find the Executor", http.StatusBadRequest)
168 | 		return
169 | 	}
170 | 
171 | 	server.Lock()
172 | 	node.LastContact = time.Now().Unix()
173 | 	server.Unlock()
174 | 
175 | 	//acknowledged the state change
176 | 	state.Acknowledged = true
177 | 
178 | 	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
179 | 	w.WriteHeader(http.StatusOK)
180 | 	if err := json.NewEncoder(w).Encode(state); err != nil {
181 | 		http.Error(w, "Unable to marshall the response", http.StatusBadRequest)
182 | 	}
183 | }
184 | 


--------------------------------------------------------------------------------
/scaleio-scheduler/scheduler/server/state.go:
--------------------------------------------------------------------------------
  1 | package server
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	"fmt"
  6 | 	"io"
  7 | 	"io/ioutil"
  8 | 	"net/http"
  9 | 	"strconv"
 10 | 
 11 | 	log "github.com/Sirupsen/logrus"
 12 | 
 13 | 	types "github.com/codedellemc/scaleio-framework/scaleio-scheduler/types"
 14 | )
 15 | 
 16 | func displayState(w http.ResponseWriter, r *http.Request, server *RestServer) {
 17 | 	response := "<html><head><title>Output</title><meta http-equiv=\"refresh\" content=\"2\" /></head><body>"
 18 | 
 19 | 	server.Lock()
 20 | 	for _, node := range server.State.ScaleIO.Nodes {
 21 | 		response += node.ExecutorID
 22 | 		response += " = "
 23 | 		switch node.State {
 24 | 		case types.StateUnknown:
 25 | 			response += "Installing Prerequisite Packages"
 26 | 
 27 | 		case types.StateCleanPrereqsReboot:
 28 | 			response += "Sync on Prerequisite Install"
 29 | 
 30 | 		case types.StatePrerequisitesInstalled:
 31 | 			response += "Installing ScaleIO Packages"
 32 | 
 33 | 		case types.StateBasePackagedInstalled:
 34 | 			response += "Creating ScaleIO Cluster"
 35 | 
 36 | 		case types.StateInitializeCluster:
 37 | 			response += "Initializing ScaleIO"
 38 | 
 39 | 		case types.StateAddResourcesToScaleIO:
 40 | 			response += "Adding resources to ScaleIO cluster"
 41 | 
 42 | 		case types.StateInstallRexRay:
 43 | 			response += "Installing REX-Ray"
 44 | 
 45 | 		case types.StateCleanInstallReboot:
 46 | 			response += "Sync Before for Reboot"
 47 | 
 48 | 		case types.StateSystemReboot:
 49 | 			response += "System is Rebooting"
 50 | 
 51 | 		case types.StateFinishInstall:
 52 | 			response += "ScaleIO Running"
 53 | 
 54 | 		case types.StateFatalInstall:
 55 | 			response += "Installation Failed"
 56 | 		}
 57 | 		response += "<br />"
 58 | 	}
 59 | 
 60 | 	capacityData := server.State.ScaleIO.CapacityData
 61 | 	usedData := server.State.ScaleIO.UsedData
 62 | 	fakeUsedData := server.State.ScaleIO.FakeUsedData
 63 | 
 64 | 	usedSpacePercent := int(float64(usedData+fakeUsedData) / float64(capacityData) * 100)
 65 | 	if capacityData == 0 {
 66 | 		usedSpacePercent = 0
 67 | 	}
 68 | 
 69 | 	if len(server.Config.AccessKey) > 0 && len(server.Config.SecretKey) > 0 {
 70 | 		response += "<br /><br /><br />"
 71 | 		response += "Capacity (KB): "
 72 | 		response += strconv.Itoa(capacityData)
 73 | 		response += "<br />"
 74 | 		response += "Fake Used Data (KB): "
 75 | 		response += strconv.Itoa(fakeUsedData)
 76 | 		response += "<br /><br />"
 77 | 		response += "Percent Used: "
 78 | 		response += strconv.Itoa(usedSpacePercent)
 79 | 		response += "<br />"
 80 | 		response += "Threshold Percent: "
 81 | 		response += strconv.Itoa(server.Config.UsedThreshold)
 82 | 		response += "<br />"
 83 | 	}
 84 | 
 85 | 	server.Unlock()
 86 | 
 87 | 	response += "</body></html>"
 88 | 
 89 | 	//log.Debugln("response:", string(response))
 90 | 	fmt.Fprintf(w, string(response))
 91 | }
 92 | 
 93 | func setState(w http.ResponseWriter, r *http.Request, server *RestServer) {
 94 | 	body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
 95 | 	if err != nil {
 96 | 		http.Error(w, "Unable to read the HTTP Body stream", http.StatusBadRequest)
 97 | 		return
 98 | 	}
 99 | 	if err := r.Body.Close(); err != nil {
100 | 		log.Warnln("Unable to close the HTTP Body stream:", err)
101 | 	}
102 | 
103 | 	state := &types.UpdateCluster{
104 | 		Acknowledged: false,
105 | 		KeyValue:     make(map[string]string),
106 | 	}
107 | 	if err := json.Unmarshal(body, &state); err != nil {
108 | 		http.Error(w, "Unable to marshall the response", http.StatusBadRequest)
109 | 		return
110 | 	}
111 | 
112 | 	//update the object
113 | 	server.Lock()
114 | 	server.State.ScaleIO.Configured = true
115 | 	server.Unlock()
116 | 
117 | 	//update the store
118 | 	err = server.Store.SetConfigured()
119 | 	if err != nil {
120 | 		http.Error(w, "Failed to update the Cluster configured bit", http.StatusBadRequest)
121 | 		return
122 | 	}
123 | 
124 | 	//acknowledged the state change
125 | 	state.Acknowledged = true
126 | 
127 | 	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
128 | 	w.WriteHeader(http.StatusOK)
129 | 	if err := json.NewEncoder(w).Encode(state); err != nil {
130 | 		http.Error(w, "Unable to marshall the response", http.StatusBadRequest)
131 | 	}
132 | }
133 | 
134 | func getState(w http.ResponseWriter, r *http.Request, server *RestServer) {
135 | 	server.Lock()
136 | 	response, err := json.MarshalIndent(server.State, "", "  ")
137 | 	server.Unlock()
138 | 
139 | 	if err != nil {
140 | 		http.Error(w, "Unable to marshall the response", http.StatusBadRequest)
141 | 		return
142 | 	}
143 | 
144 | 	log.Debugln("response:", string(response))
145 | 	fmt.Fprintf(w, string(response))
146 | }
147 | 


--------------------------------------------------------------------------------
/scaleio-scheduler/scheduler/server/version.go:
--------------------------------------------------------------------------------
 1 | package server
 2 | 
 3 | import (
 4 | 	"encoding/json"
 5 | 	"fmt"
 6 | 	"net/http"
 7 | 
 8 | 	log "github.com/Sirupsen/logrus"
 9 | 
10 | 	"github.com/codedellemc/scaleio-framework/scaleio-scheduler/config"
11 | 	types "github.com/codedellemc/scaleio-framework/scaleio-scheduler/types"
12 | )
13 | 
14 | func getVersion(w http.ResponseWriter, r *http.Request, server *RestServer) {
15 | 	ver := types.Version{
16 | 		VersionInt: config.VersionInt,
17 | 		VersionStr: config.VersionStr,
18 | 		BuildStr:   "",
19 | 	}
20 | 
21 | 	response, err := json.MarshalIndent(ver, "", "  ")
22 | 	if err != nil {
23 | 		http.Error(w, "Unable to marshall the response", http.StatusBadRequest)
24 | 		return
25 | 	}
26 | 
27 | 	log.Debugln("response:", string(response))
28 | 	fmt.Fprintf(w, string(response))
29 | }
30 | 


--------------------------------------------------------------------------------
/scaleio-scheduler/switch.sh:
--------------------------------------------------------------------------------
 1 | #! /usr/bin/env bash
 2 | 
 3 | if [ "$1" == "which" ]; then
 4 |     if [ -f glide.yaml.dev ]; then
 5 |         echo "Building PROD"
 6 |     elif [ -f glide.yaml.org ]; then
 7 |         echo "Building DEV"
 8 |     fi
 9 | elif [ -f glide.yaml.dev ]; then
10 |     echo "Enabling DEV"
11 |     mv glide.yaml glide.yaml.org
12 |     mv glide.yaml.dev glide.yaml
13 | elif [ -f glide.yaml.org ]; then
14 |     echo "Enabling PROD"
15 |     mv glide.yaml glide.yaml.dev
16 |     mv glide.yaml.org glide.yaml
17 | fi


--------------------------------------------------------------------------------
/version.sh:
--------------------------------------------------------------------------------
 1 | #! /usr/bin/env bash
 2 | #echo "$#"
 3 | #echo "$1"
 4 | #echo "$2"
 5 | if [ "$#" -eq 0 ]; then
 6 |   echo "version [old ver] [new ver]"
 7 |   exit 1
 8 | fi
 9 | 
10 | if [ "$#" -eq 1 ]; then
11 |   tmp=`echo $1 | sed 's/\\./\\\\./g'`
12 |   #echo $tmp
13 |   grep -R --exclude-dir vendor --exclude-dir .docs/about --exclude-dir .git --exclude-dir mesos --exclude scaleio-executor --exclude scaleio-scheduler --exclude build.sh $tmp ./
14 | else
15 |   tmp=`echo $1 | sed 's/\\./\\\\\\./g'`
16 |   #echo $tmp
17 |   find . -type f -name '*.json' -exec sed -i '' 's/'"$tmp"'/'"$2"'/g' {} +
18 |   find . -path ./.docs/about -prune -o -type f -name '*.md' -exec sed -i '' 's/'"$tmp"'/'"$2"'/g' {} +
19 |   find . -type f -name '*.go' -exec sed -i '' 's/'"$tmp"'/'"$2"'/g' {} +
20 |   find . -type f -name 'VERSION' -exec sed -i '' 's/'"$tmp"'/'"$2"'/g' {} +
21 | fi
22 | 


--------------------------------------------------------------------------------